Trait snarkvm_circuit::environment::OutputMode

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

    // Required method
    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.

Implementations on Foreign Types

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Sub<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Shr<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Shl<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn DivWrapped<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

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

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn BitAnd<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = ()

fn output_mode( _case: &<Integer<E, I> as OutputMode<dyn One<Boolean = Boolean<E>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Add<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn ShrWrapped<Integer<E, M>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn RemChecked<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

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

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Ternary<Output = Integer<E, I>, Boolean = Boolean<E>>>>::Case ) -> Mode

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

type Case = Mode

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn AbsWrapped<Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn MulChecked<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

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

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn BitOr<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Div<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = Mode

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Neg<Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Compare<Integer<E, I>, Output = Boolean<E>>>>::Case ) -> Mode

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

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

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn PowWrapped<Integer<E, M>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Mul<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn MulWrapped<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

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

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn BitXor<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn ShlChecked<Integer<E, M>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn AddWrapped<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn SubWrapped<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

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

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn PowChecked<Integer<E, M>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn ShrChecked<Integer<E, M>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn RemWrapped<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = Mode

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Not<Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn AddChecked<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Rem<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = ()

fn output_mode( _case: &<Integer<E, I> as OutputMode<dyn Zero<Boolean = Boolean<E>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn Equal<Integer<E, I>, Output = Boolean<E>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn ShlWrapped<Integer<E, M>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn DivChecked<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = (Mode, Mode)

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn SubChecked<Integer<E, I>, Output = Integer<E, I>>>>::Case ) -> Mode

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

type Case = Mode

fn output_mode( case: &<Integer<E, I> as OutputMode<dyn AbsChecked<Output = Integer<E, I>>>>::Case ) -> Mode

Implementors

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

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

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

type Case = (Mode, Mode)

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

type Case = (Mode, Mode)

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

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

impl<E> OutputMode<dyn DivUnchecked<Field<E>, Output = Field<E>>> for Field<E>where E: Environment,

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

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

type Case = Mode

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

type Case = (Mode, Mode)

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

type Case = Vec<Mode, Global>

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

type Case = Mode

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

type Case = Mode

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

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

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

type Case = Mode

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

type Case = Mode

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

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

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

type Case = Mode

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

type Case = ()

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

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

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

type Case = Mode

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

type Case = Mode

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

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

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

type Case = (Mode, Mode)

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

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

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

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

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

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

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

type Case = Mode

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

type Case = Mode

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

type Case = Mode

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

type Case = ()

impl<E, const NUM_BITS: u8> OutputMode<dyn Commit<Output = Field<E>, Randomizer = Scalar<E>, Input = Boolean<E>>> 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<Randomizer = Scalar<E>, Output = Group<E>, Input = Boolean<E>>> 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>>> 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>>> for Pedersen<E, NUM_BITS>where E: Environment,

type Case = Vec<Mode, Global>