Trait snarkvm_gadgets::traits::utilities::alloc::AllocGadget

pub trait AllocGadget<V: ?Sized, F: Field>: Sized {
    fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
        cs: CS, 
        f: Fn
    ) -> Result<Self, SynthesisError>;
    fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
        cs: CS, 
        f: Fn
    ) -> Result<Self, SynthesisError>;

    fn alloc_constant<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
        _cs: CS, 
        _f: Fn
    ) -> Result<Self, SynthesisError> { ... }
    fn alloc_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
        cs: CS, 
        f: Fn
    ) -> Result<Self, SynthesisError> { ... }
    fn alloc_input_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
        cs: CS, 
        f: Fn
    ) -> Result<Self, SynthesisError> { ... }
}

Required methods

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

Provided methods

fn alloc_constant<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    _cs: CS,
    _f: Fn
) -> Result<Self, SynthesisError>

fn alloc_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

Implementations on Foreign Types

impl<I, F: Field, A: AllocGadget<I, F>> AllocGadget<[I], F> for Vec<A>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[I]>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[I]>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[I]>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[I]>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

Implementors

impl<C, H, CGadget, HGadget, F> AllocGadget<CommitmentMerklePath<C, H>, F> for CommitmentMerklePathGadget<C, H, CGadget, HGadget, F> where
    C: CommitmentScheme,
    H: CRH,
    CGadget: CommitmentGadget<C, F>,
    HGadget: CRHGadget<H, F>,
    F: Field, 

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<CommitmentMerklePath<C, H>>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<CommitmentMerklePath<C, H>>, 

impl<F: Field> AllocGadget<<Int8 as Integer>::IntegerType, F> for Int8

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int8 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int8 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<Int16 as Integer>::IntegerType, F> for Int16

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int16 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int16 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<Int32 as Integer>::IntegerType, F> for Int32

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int32 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int32 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<Int64 as Integer>::IntegerType, F> for Int64

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int64 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int64 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<Int128 as Integer>::IntegerType, F> for Int128

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int128 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<Int128 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<UInt128 as Integer>::IntegerType, F> for UInt128

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt128 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt128 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<UInt8 as Integer>::IntegerType, F> for UInt8

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt8 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt8 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<UInt16 as Integer>::IntegerType, F> for UInt16

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt16 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt16 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<UInt32 as Integer>::IntegerType, F> for UInt32

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt32 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt32 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<<UInt64 as Integer>::IntegerType, F> for UInt64

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt64 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<UInt64 as Integer>::IntegerType>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: Field> AllocGadget<bool, F> for Boolean

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

impl<F: Field> AllocGadget<bool, F> for AllocatedBit

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

impl<F: Field> AllocGadget<(), F> for Blake2sParametersGadget

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<()>, CS: ConstraintSystem<F>>(
    _: CS,
    _: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<()>, CS: ConstraintSystem<F>>(
    _: CS,
    _: Fn
) -> Result<Self, SynthesisError>

impl<F: PrimeField> AllocGadget<[u8; 32], F> for Blake2sRandomnessGadget

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[u8; 32]>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[u8; 32]>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: PrimeField> AllocGadget<[u8; 32], F> for Blake2sOutputGadget

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[u8; 32]>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<[u8; 32]>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<F: PrimeField> AllocGadget<F, F> for FpGadget<F>

fn alloc_constant<FN, T, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<F>, 

fn alloc<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<F>, 

fn alloc_input<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<F>, 

impl<F: PrimeField> AllocGadget<F, F> for AllocatedFp<F>

fn alloc_constant<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<F>, 

fn alloc<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<F>, 

fn alloc_input<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<F>, 

impl<F: PrimeField, CF: PrimeField> AllocGadget<Vec<F, Global>, CF> for BooleanInputGadget<F, CF>

fn alloc_constant<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<F>>, CS: ConstraintSystem<CF>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<F>>, CS: ConstraintSystem<CF>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<F>>, CS: ConstraintSystem<CF>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group + ProjectiveCurve, F: Field> AllocGadget<GroupEncryptionParameters<G>, F> for GroupEncryptionParametersGadget<G>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<GroupEncryptionParameters<G>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<GroupEncryptionParameters<G>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group + ProjectiveCurve, F: Field, GG: CompressedGroupGadget<G, F>> AllocGadget<Vec<G, Global>, F> for GroupEncryptionCiphertextGadget<G, F, GG>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

impl<G: Group + ProjectiveCurve, F: Field, GG: GroupGadget<G, F>> AllocGadget<Vec<G, Global>, F> for GroupEncryptionPlaintextGadget<G, F, GG>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

impl<G: Group + ProjectiveCurve, F: Field, GG: GroupGadget<G, F>> AllocGadget<GroupEncryptionPublicKey<G>, F> for GroupEncryptionPublicKeyGadget<G, F, GG>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<GroupEncryptionPublicKey<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<GroupEncryptionPublicKey<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

impl<G: Group + CanonicalSerialize + CanonicalDeserialize, F: Field, GG: GroupGadget<G, F>> AllocGadget<SchnorrPublicKey<G>, F> for SchnorrPublicKeyGadget<G, F, GG>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<SchnorrPublicKey<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<SchnorrPublicKey<G>>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, F: Field, D: Digest> AllocGadget<SchnorrParameters<G, D>, F> for SchnorrParametersGadget<G, F, D>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<SchnorrParameters<G, D>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<SchnorrParameters<G, D>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, F: PrimeField> AllocGadget<<G as Group>::ScalarField, F> for PedersenRandomnessGadget<G>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G::ScalarField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G::ScalarField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, F: PrimeField> AllocGadget<<G as Group>::ScalarField, F> for GroupEncryptionPrivateKeyGadget<G>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G::ScalarField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G::ScalarField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, F: PrimeField> AllocGadget<<G as Group>::ScalarField, F> for GroupEncryptionRandomnessGadget<G>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G::ScalarField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G::ScalarField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, F: PrimeField> AllocGadget<Vec<<G as Group>::ScalarField, Global>, F> for GroupEncryptionBlindingExponentsGadget<G>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<G::ScalarField>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Vec<G::ScalarField>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, S: PedersenSize, F: Field, GG: GroupGadget<G, F>> AllocGadget<PedersenCRHParameters<G, S>, F> for PedersenCRHParametersGadget<G, S, F, GG>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<PedersenCRHParameters<G, S>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<PedersenCRHParameters<G, S>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<G: Group, S: PedersenSize, F: PrimeField> AllocGadget<PedersenCommitmentParameters<G, S>, F> for PedersenCommitmentParametersGadget<G, S, F>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<PedersenCommitmentParameters<G, S>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<PedersenCommitmentParameters<G, S>>, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<P, F: PrimeField> AllocGadget<Fp6<P>, F> for Fp6Gadget<P, F> where
    P: Fp6Parameters,
    P::Fp2Params: Fp2Parameters<Fp = F>, 

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Fp6<P>>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Fp6<P>>, 

impl<P, F: PrimeField> AllocGadget<Fp12<P>, F> for Fp12Gadget<P, F> where
    P: Fp12Parameters,
    <P::Fp6Params as Fp6Parameters>::Fp2Params: Fp2Parameters<Fp = F>, 

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Fp12<P>>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Fp12<P>>, 

impl<P, HGadget, F> AllocGadget<MerklePath<P>, F> for MerklePathGadget<P, HGadget, F> where
    P: MerkleParameters,
    HGadget: CRHGadget<P::H, F>,
    F: Field, 

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<MerklePath<P>>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<MerklePath<P>>, 

impl<P: Bls12Parameters> AllocGadget<G2Prepared<P>, <P as Bls12Parameters>::Fp> for G2PreparedGadget<P>

fn alloc_constant<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G2Prepared<P>>, CS: ConstraintSystem<<P as Bls12Parameters>::Fp>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G2Prepared<P>>, CS: ConstraintSystem<<P as Bls12Parameters>::Fp>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<G2Prepared<P>>, CS: ConstraintSystem<<P as Bls12Parameters>::Fp>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<P: MontgomeryModelParameters, F: PrimeField> AllocGadget<<P as ModelParameters>::BaseField, F> for Elligator2FieldGadget<P, F>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<P as ModelParameters>::BaseField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<<P as ModelParameters>::BaseField>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<P: SWModelParameters, F: PrimeField, FG: FieldGadget<P::BaseField, F>> AllocGadget<GroupProjective<P>, F> for snarkvm_gadgets::curves::templates::bls12::affine::AffineGadget<P, F, FG>

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<SWProjective<P>>, 

fn alloc_checked<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<SWProjective<P>>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<SWProjective<P>>, 

impl<P: TEModelParameters, F: Field, FG: FieldGadget<P::BaseField, F>> AllocGadget<GroupAffine<P>, F> for snarkvm_gadgets::curves::templates::twisted_edwards::AffineGadget<P, F, FG> where
    Self: GroupGadget<TEAffine<P>, F>, 

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<TEAffine<P>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<TEAffine<P>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<TEAffine<P>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<P: TEModelParameters, F: Field, FG: FieldGadget<P::BaseField, F>> AllocGadget<GroupProjective<P>, F> for snarkvm_gadgets::curves::templates::twisted_edwards::AffineGadget<P, F, FG> where
    Self: GroupGadget<TEProjective<P>, F>, 

fn alloc<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<TEProjective<P>>, 

fn alloc_checked<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<TEProjective<P>>, 

fn alloc_input<FN, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<TEProjective<P>>, 

impl<P: Fp2Parameters<Fp = F>, F: PrimeField> AllocGadget<Fp2<P>, F> for Fp2Gadget<P, F>

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Fp2<P>>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Fp2<P>>, 

impl<Pairing: PairingEngine, F: Field, P: PairingGadget<Pairing, F>> AllocGadget<Proof<Pairing>, F> for GM17ProofGadget<Pairing, F, P>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Proof<Pairing>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<Proof<Pairing>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<Pairing: PairingEngine, F: Field, P: PairingGadget<Pairing, F>> AllocGadget<VerifyingKey<Pairing>, F> for GM17VerifyingKeyGadget<Pairing, F, P>

fn alloc<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<VerifyingKey<Pairing>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

fn alloc_input<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<VerifyingKey<Pairing>>, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError>

impl<PairingE, ConstraintF, P> AllocGadget<Proof<PairingE>, ConstraintF> for ProofGadget<PairingE, ConstraintF, P> where
    PairingE: PairingEngine,
    ConstraintF: Field,
    P: PairingGadget<PairingE, ConstraintF>, 

fn alloc<FN, T, CS: ConstraintSystem<ConstraintF>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Proof<PairingE>>, 

fn alloc_input<FN, T, CS: ConstraintSystem<ConstraintF>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<Proof<PairingE>>, 

impl<PairingE, ConstraintF, P> AllocGadget<VerifyingKey<PairingE>, ConstraintF> for VerifyingKeyGadget<PairingE, ConstraintF, P> where
    PairingE: PairingEngine,
    ConstraintF: Field,
    P: PairingGadget<PairingE, ConstraintF>, 

fn alloc<FN, T, CS: ConstraintSystem<ConstraintF>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<VerifyingKey<PairingE>>, 

fn alloc_input<FN, T, CS: ConstraintSystem<ConstraintF>>(
    cs: CS,
    value_gen: FN
) -> Result<Self, SynthesisError> where
    FN: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<VerifyingKey<PairingE>>,