Trait snarkvm_circuit::prelude::OutputMode

pub trait OutputMode<Op> where
    Op: ?Sized, {
    type Case: ?Sized;

    fn output_mode(input: &Self::Case) -> Mode;
}

Trait for determining the mode of the output of an operation.

Required Associated Types

type Case: ?Sized

Required Methods

fn output_mode(input: &Self::Case) -> Mode

Returns the mode of the output.

Implementors

impl<E> OutputMode<dyn Add<Field<E>, Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

impl<E> OutputMode<dyn Add<Group<E>, Output = Group<E>> + 'static> for Group<E> where
    E: Environment, 

type Case = (Mode, Mode)

impl<E> OutputMode<dyn Add<Scalar<E>, Output = Scalar<E>> + 'static> for Scalar<E> where
    E: Environment, 

type Case = (Mode, Mode)

impl<E> OutputMode<dyn Div<Field<E>, Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

impl<E> OutputMode<dyn Double<Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Equal<Field<E>, Output = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (Mode, Mode)

impl<E> OutputMode<dyn FromBits<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Vec<Mode, Global>

impl<E> OutputMode<dyn FromBoolean<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Inverse<Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Mul<Field<E>, Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

impl<E> OutputMode<dyn Neg<Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Neg<Output = Group<E>> + 'static> for Group<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Nor<Boolean<E>, Output = Boolean<E>> + 'static> for Boolean<E> where
    E: Environment, 

type Case = (CircuitType<Boolean<E>>, CircuitType<Boolean<E>>)

impl<E> OutputMode<dyn Not<Output = Boolean<E>> + 'static> for Boolean<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn One<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = ()

impl<E> OutputMode<dyn Pow<Field<E>, Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

impl<E> OutputMode<dyn Square<Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn SquareRoot<Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Sub<Field<E>, Output = Field<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

impl<E> OutputMode<dyn Sub<Group<E>, Output = Group<E>> + 'static> for Group<E> where
    E: Environment, 

type Case = (Mode, Mode)

impl<E> OutputMode<dyn Ternary<Output = Address<E>, Boolean = Boolean<E>> + 'static> for Address<E> where
    E: Environment, 

type Case = (CircuitType<Boolean<E>>, Mode, Mode)

impl<E> OutputMode<dyn Ternary<Output = Field<E>, Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = (CircuitType<Boolean<E>>, Mode, Mode)

impl<E> OutputMode<dyn Ternary<Output = Group<E>, Boolean = Boolean<E>> + 'static> for Group<E> where
    E: Environment, 

type Case = (CircuitType<Boolean<E>>, Mode, Mode)

impl<E> OutputMode<dyn ToBits<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn ToLowerBits<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn ToUpperBits<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = Mode

impl<E> OutputMode<dyn Zero<Boolean = Boolean<E>> + 'static> for Field<E> where
    E: Environment, 

type Case = ()

impl<E, I> OutputMode<dyn AbsChecked<Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = Mode

impl<E, I> OutputMode<dyn AbsWrapped<Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = Mode

impl<E, I> OutputMode<dyn Add<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn AddChecked<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn AddWrapped<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn BitAnd<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (CircuitType<Integer<E, I>>, CircuitType<Integer<E, I>>)

impl<E, I> OutputMode<dyn BitOr<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (CircuitType<Integer<E, I>>, CircuitType<Integer<E, I>>)

impl<E, I> OutputMode<dyn BitXor<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (CircuitType<Integer<E, I>>, CircuitType<Integer<E, I>>)

impl<E, I> OutputMode<dyn Compare<Integer<E, I>, Output = Boolean<E>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Div<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn DivChecked<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn DivWrapped<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Equal<Integer<E, I>, Output = Boolean<E>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Mul<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn MulChecked<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn MulWrapped<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Neg<Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = Mode

impl<E, I> OutputMode<dyn Not<Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = Mode

impl<E, I> OutputMode<dyn One<Boolean = Boolean<E>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = ()

impl<E, I> OutputMode<dyn Rem<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn RemChecked<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn RemWrapped<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Shl<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Shr<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Sub<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn SubChecked<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn SubWrapped<Integer<E, I>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (Mode, Mode)

impl<E, I> OutputMode<dyn Ternary<Output = Integer<E, I>, Boolean = Boolean<E>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = (CircuitType<Boolean<E>>, Mode, Mode)

impl<E, I> OutputMode<dyn Zero<Boolean = Boolean<E>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

type Case = ()

impl<E, I, M> OutputMode<dyn PowChecked<Integer<E, M>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType,
    M: Magnitude, 

type Case = (Mode, CircuitType<Integer<E, M>>)

impl<E, I, M> OutputMode<dyn PowWrapped<Integer<E, M>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType,
    M: Magnitude, 

type Case = (Mode, CircuitType<Integer<E, M>>)

impl<E, I, M> OutputMode<dyn ShlChecked<Integer<E, M>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType,
    M: Magnitude, 

type Case = (Mode, Mode)

impl<E, I, M> OutputMode<dyn ShlWrapped<Integer<E, M>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType,
    M: Magnitude, 

type Case = (Mode, Mode)

impl<E, I, M> OutputMode<dyn ShrChecked<Integer<E, M>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType,
    M: Magnitude, 

type Case = (Mode, Mode)

impl<E, I, M> OutputMode<dyn ShrWrapped<Integer<E, M>, Output = Integer<E, I>> + 'static> for Integer<E, I> where
    E: Environment,
    I: IntegerType,
    M: Magnitude, 

type Case = (Mode, Mode)

impl<E, const NUM_BITS: u8> OutputMode<dyn Commit<Randomizer = Scalar<E>, Input = Boolean<E>, Output = Field<E>> + 'static> for Pedersen<E, NUM_BITS> where
    E: Environment, 

type Case = (Vec<Mode, Global>, Vec<Mode, Global>)

impl<E, const NUM_BITS: u8> OutputMode<dyn CommitUncompressed<Output = Group<E>, Input = Boolean<E>, Randomizer = Scalar<E>> + 'static> for Pedersen<E, NUM_BITS> where
    E: Environment, 

type Case = (Vec<Mode, Global>, Vec<Mode, Global>)

impl<E, const NUM_BITS: u8> OutputMode<dyn Hash<Output = Field<E>, Input = Boolean<E>> + 'static> for Pedersen<E, NUM_BITS> where
    E: Environment, 

type Case = Vec<Mode, Global>

impl<E, const NUM_BITS: u8> OutputMode<dyn HashUncompressed<Input = Boolean<E>, Output = Group<E>> + 'static> for Pedersen<E, NUM_BITS> where
    E: Environment, 

type Case = Vec<Mode, Global>