Enum sp1_recursion_compiler::ir::DslIr

source · 
pub enum DslIr<C: Config> {

Show 108 variants    ImmV(Var<C::N>, C::N),
    ImmF(Felt<C::F>, C::F),
    ImmE(Ext<C::F, C::EF>, C::EF),
    AddV(Var<C::N>, Var<C::N>, Var<C::N>),
    AddVI(Var<C::N>, Var<C::N>, C::N),
    AddF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    AddFI(Felt<C::F>, Felt<C::F>, C::F),
    AddE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    AddEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    AddEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    AddEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    AddEFFI(Ext<C::F, C::EF>, Felt<C::F>, C::EF),
    SubV(Var<C::N>, Var<C::N>, Var<C::N>),
    SubVI(Var<C::N>, Var<C::N>, C::N),
    SubVIN(Var<C::N>, C::N, Var<C::N>),
    SubF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    SubFI(Felt<C::F>, Felt<C::F>, C::F),
    SubFIN(Felt<C::F>, C::F, Felt<C::F>),
    SubE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    SubEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    SubEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>),
    SubEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    SubEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    MulV(Var<C::N>, Var<C::N>, Var<C::N>),
    MulVI(Var<C::N>, Var<C::N>, C::N),
    MulF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    MulFI(Felt<C::F>, Felt<C::F>, C::F),
    MulE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    MulEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    MulEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    MulEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    DivF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    DivFI(Felt<C::F>, Felt<C::F>, C::F),
    DivFIN(Felt<C::F>, C::F, Felt<C::F>),
    DivE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    DivEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    DivEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>),
    DivEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    DivEFIN(Ext<C::F, C::EF>, C::F, Ext<C::F, C::EF>),
    DivEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    NegV(Var<C::N>, Var<C::N>),
    NegF(Felt<C::F>, Felt<C::F>),
    NegE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    InvV(Var<C::N>, Var<C::N>),
    InvF(Felt<C::F>, Felt<C::F>),
    InvE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    For(Usize<C::N>, Usize<C::N>, C::N, Var<C::N>, TracedVec<DslIr<C>>),
    IfEq(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    IfNe(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    IfEqI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    IfNeI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    Break,
    AssertEqV(Var<C::N>, Var<C::N>),
    AssertNeV(Var<C::N>, Var<C::N>),
    AssertEqF(Felt<C::F>, Felt<C::F>),
    AssertNeF(Felt<C::F>, Felt<C::F>),
    AssertEqE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    AssertNeE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    AssertEqVI(Var<C::N>, C::N),
    AssertNeVI(Var<C::N>, C::N),
    AssertEqFI(Felt<C::F>, C::F),
    AssertNeFI(Felt<C::F>, C::F),
    AssertEqEI(Ext<C::F, C::EF>, C::EF),
    AssertNeEI(Ext<C::F, C::EF>, C::EF),
    Alloc(Ptr<C::N>, Usize<C::N>, usize),
    LoadV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>),
    LoadF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>),
    LoadE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>),
    StoreV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>),
    StoreF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>),
    StoreE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>),
    CircuitNum2BitsV(Var<C::N>, usize, Vec<Var<C::N>>),
    CircuitNum2BitsF(Felt<C::F>, Vec<Var<C::N>>),
    Poseidon2PermuteBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>),
    Poseidon2CompressBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>, Array<C, Felt<C::F>>),
    Poseidon2AbsorbBabyBear(Var<C::N>, Array<C, Felt<C::F>>),
    Poseidon2FinalizeBabyBear(Var<C::N>, Array<C, Felt<C::F>>),
    CircuitPoseidon2Permute([Var<C::N>; 3]),
    CircuitPoseidon2PermuteBabyBear([Felt<C::F>; 16]),
    HintBitsU(Array<C, Var<C::N>>, Usize<C::N>),
    HintBitsV(Array<C, Var<C::N>>, Var<C::N>),
    HintBitsF(Array<C, Var<C::N>>, Felt<C::F>),
    PrintV(Var<C::N>),
    PrintF(Felt<C::F>),
    PrintE(Ext<C::F, C::EF>),
    Error(),
    HintExt2Felt(Array<C, Felt<C::F>>, Ext<C::F, C::EF>),
    HintLen(Var<C::N>),
    HintVars(Array<C, Var<C::N>>),
    HintFelts(Array<C, Felt<C::F>>),
    HintExts(Array<C, Ext<C::F, C::EF>>),
    WitnessVar(Var<C::N>, u32),
    WitnessFelt(Felt<C::F>, u32),
    WitnessExt(Ext<C::F, C::EF>, u32),
    Commit(Felt<C::F>, Var<C::N>),
    RegisterPublicValue(Felt<C::F>),
    Halt,
    CircuitCommitVkeyHash(Var<C::N>),
    CircuitCommitCommitedValuesDigest(Var<C::N>),
    FriFold(Var<C::N>, Array<C, FriFoldInput<C>>),
    CircuitSelectV(Var<C::N>, Var<C::N>, Var<C::N>, Var<C::N>),
    CircuitSelectF(Var<C::N>, Felt<C::F>, Felt<C::F>, Felt<C::F>),
    CircuitSelectE(Var<C::N>, Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    CircuitExt2Felt([Felt<C::F>; 4], Ext<C::F, C::EF>),
    CircuitFelts2Ext([Felt<C::F>; 4], Ext<C::F, C::EF>),
    LessThan(Var<C::N>, Var<C::N>, Var<C::N>),
    CycleTracker(String),
    ExpReverseBitsLen(Ptr<C::N>, Var<C::N>, Var<C::N>),

}
Expand description

An intermeddiate instruction set for implementing programs.

Programs written in the DSL can compile both to the recursive zkVM and the R1CS or Plonk-ish circuits.

Variants§

§

ImmV(Var<C::N>, C::N)

Assigns an immediate to a variable (var = imm).

§

ImmF(Felt<C::F>, C::F)

Assigns a field immediate to a field element (felt = field imm).

§

ImmE(Ext<C::F, C::EF>, C::EF)

Assigns an ext field immediate to an extension field element (ext = ext field imm).

§

AddV(Var<C::N>, Var<C::N>, Var<C::N>)

Add two variables (var = var + var).

§

AddVI(Var<C::N>, Var<C::N>, C::N)

Add a variable and an immediate (var = var + imm).

§

AddF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Add two field elements (felt = felt + felt).

§

AddFI(Felt<C::F>, Felt<C::F>, C::F)

Add a field element and a field immediate (felt = felt + field imm).

§

AddE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Add two extension field elements (ext = ext + ext).

§

AddEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Add an extension field element and an ext field immediate (ext = ext + ext field imm).

§

AddEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Add an extension field element and a field element (ext = ext + felt).

§

AddEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Add an extension field element and a field immediate (ext = ext + field imm).

§

AddEFFI(Ext<C::F, C::EF>, Felt<C::F>, C::EF)

Add a field element and an ext field immediate (ext = felt + ext field imm).

§

SubV(Var<C::N>, Var<C::N>, Var<C::N>)

Subtracts two variables (var = var - var).

§

SubVI(Var<C::N>, Var<C::N>, C::N)

Subtracts a variable and an immediate (var = var - imm).

§

SubVIN(Var<C::N>, C::N, Var<C::N>)

Subtracts an immediate and a variable (var = imm - var).

§

SubF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Subtracts two field elements (felt = felt - felt).

§

SubFI(Felt<C::F>, Felt<C::F>, C::F)

Subtracts a field element and a field immediate (felt = felt - field imm).

§

SubFIN(Felt<C::F>, C::F, Felt<C::F>)

Subtracts a field immediate and a field element (felt = field imm - felt).

§

SubE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Subtracts two extension field elements (ext = ext - ext).

§

SubEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Subtrancts an extension field element and an extension field immediate (ext = ext - ext field imm).

§

SubEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>)

Subtracts an extension field immediate and an extension field element (ext = ext field imm - ext).

§

SubEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Subtracts an extension field element and a field immediate (ext = ext - field imm).

§

SubEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Subtracts an extension field element and a field element (ext = ext - felt).

§

MulV(Var<C::N>, Var<C::N>, Var<C::N>)

Multiplies two variables (var = var * var).

§

MulVI(Var<C::N>, Var<C::N>, C::N)

Multiplies a variable and an immediate (var = var * imm).

§

MulF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Multiplies two field elements (felt = felt * felt).

§

MulFI(Felt<C::F>, Felt<C::F>, C::F)

Multiplies a field element and a field immediate (felt = felt * field imm).

§

MulE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Multiplies two extension field elements (ext = ext * ext).

§

MulEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Multiplies an extension field element and an extension field immediate (ext = ext * ext field imm).

§

MulEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Multiplies an extension field element and a field immediate (ext = ext * field imm).

§

MulEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Multiplies an extension field element and a field element (ext = ext * felt).

§

DivF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Divides two variables (var = var / var).

§

DivFI(Felt<C::F>, Felt<C::F>, C::F)

Divides a field element and a field immediate (felt = felt / field imm).

§

DivFIN(Felt<C::F>, C::F, Felt<C::F>)

Divides a field immediate and a field element (felt = field imm / felt).

§

DivE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Divides two extension field elements (ext = ext / ext).

§

DivEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Divides an extension field element and an extension field immediate (ext = ext / ext field imm).

§

DivEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>)

Divides and extension field immediate and an extension field element (ext = ext field imm / ext).

§

DivEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Divides an extension field element and a field immediate (ext = ext / field imm).

§

DivEFIN(Ext<C::F, C::EF>, C::F, Ext<C::F, C::EF>)

Divides a field immediate and an extension field element (ext = field imm / ext).

§

DivEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Divides an extension field element and a field element (ext = ext / felt).

§

NegV(Var<C::N>, Var<C::N>)

Negates a variable (var = -var).

§

NegF(Felt<C::F>, Felt<C::F>)

Negates a field element (felt = -felt).

§

NegE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Negates an extension field element (ext = -ext).

§

InvV(Var<C::N>, Var<C::N>)

Inverts a variable (var = 1 / var).

§

InvF(Felt<C::F>, Felt<C::F>)

Inverts a field element (felt = 1 / felt).

§

InvE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Inverts an extension field element (ext = 1 / ext).

§

For(Usize<C::N>, Usize<C::N>, C::N, Var<C::N>, TracedVec<DslIr<C>>)

Executes a for loop with the parameters (start step value, end step value, step size, step variable, body).

§

IfEq(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes an equal conditional branch with the parameters (lhs var, rhs var, then body, else body).

§

IfNe(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes a not equal conditional branch with the parameters (lhs var, rhs var, then body, else body).

§

IfEqI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes an equal conditional branch with the parameters (lhs var, rhs imm, then body, else body).

§

IfNeI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes a not equal conditional branch with the parameters (lhs var, rhs imm, then body, else body).

§

Break

Break out of a for loop.

§

AssertEqV(Var<C::N>, Var<C::N>)

Assert that two variables are equal (var == var).

§

AssertNeV(Var<C::N>, Var<C::N>)

Assert that two variables are not equal (var != var).

§

AssertEqF(Felt<C::F>, Felt<C::F>)

Assert that two field elements are equal (felt == felt).

§

AssertNeF(Felt<C::F>, Felt<C::F>)

Assert that two field elements are not equal (felt != felt).

§

AssertEqE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Assert that two extension field elements are equal (ext == ext).

§

AssertNeE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Assert that two extension field elements are not equal (ext != ext).

§

AssertEqVI(Var<C::N>, C::N)

Assert that a variable is equal to an immediate (var == imm).

§

AssertNeVI(Var<C::N>, C::N)

Assert that a variable is not equal to an immediate (var != imm).

§

AssertEqFI(Felt<C::F>, C::F)

Assert that a field element is equal to a field immediate (felt == field imm).

§

AssertNeFI(Felt<C::F>, C::F)

Assert that a field element is not equal to a field immediate (felt != field imm).

§

AssertEqEI(Ext<C::F, C::EF>, C::EF)

Assert that an extension field element is equal to an extension field immediate (ext == ext field imm).

§

AssertNeEI(Ext<C::F, C::EF>, C::EF)

Assert that an extension field element is not equal to an extension field immediate (ext != ext field imm).

§

Alloc(Ptr<C::N>, Usize<C::N>, usize)

Allocate (ptr, len, size) a memory slice of length len

§

LoadV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>)

Load variable (var, ptr, index)

§

LoadF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>)

Load field element (var, ptr, index)

§

LoadE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>)

Load extension field

§

StoreV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>)

Store variable at address

§

StoreF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>)

Store field element at address

§

StoreE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>)

Store extension field at address

§

CircuitNum2BitsV(Var<C::N>, usize, Vec<Var<C::N>>)

Decompose a variable into size bits (bits = num2bits(var, size)). Should only be used when target is a gnark circuit.

§

CircuitNum2BitsF(Felt<C::F>, Vec<Var<C::N>>)

Decompose a field element into bits (bits = num2bits(felt)). Should only be used when target is a gnark circuit.

§

Poseidon2PermuteBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>)

Permutes an array of baby bear elements using Poseidon2 (output = p2_permute(array)).

§

Poseidon2CompressBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>, Array<C, Felt<C::F>>)

Compresses two baby bear element arrays using Poseidon2 (output = p2_compress(array1, array2)).

§

Poseidon2AbsorbBabyBear(Var<C::N>, Array<C, Felt<C::F>>)

Absorb an array of baby bear elements for a specified hash instance.

§

Poseidon2FinalizeBabyBear(Var<C::N>, Array<C, Felt<C::F>>)

Finalize and return the hash digest of a specified hash instance.

§

CircuitPoseidon2Permute([Var<C::N>; 3])

Permutes an array of Bn254 elements using Poseidon2 (output = p2_permute(array)). Should only be used when target is a gnark circuit.

§

CircuitPoseidon2PermuteBabyBear([Felt<C::F>; 16])

Permutates an array of BabyBear elements in the circuit.

§

HintBitsU(Array<C, Var<C::N>>, Usize<C::N>)

Decompose hint operation of a usize into an array. (output = num2bits(usize)).

§

HintBitsV(Array<C, Var<C::N>>, Var<C::N>)

Decompose hint operation of a variable into an array. (output = num2bits(var)).

§

HintBitsF(Array<C, Var<C::N>>, Felt<C::F>)

Decompose hint operation of a field element into an array. (output = num2bits(felt)).

§

PrintV(Var<C::N>)

Prints a variable.

§

PrintF(Felt<C::F>)

Prints a field element.

§

PrintE(Ext<C::F, C::EF>)

Prints an extension field element.

§

Error()

Throws an error.

§

HintExt2Felt(Array<C, Felt<C::F>>, Ext<C::F, C::EF>)

Converts an ext to a slice of felts.

§

HintLen(Var<C::N>)

Hint the length of the next array.

§

HintVars(Array<C, Var<C::N>>)

Hint an array of variables.

§

HintFelts(Array<C, Felt<C::F>>)

Hint an array of field elements.

§

HintExts(Array<C, Ext<C::F, C::EF>>)

Hint an array of extension field elements.

§

WitnessVar(Var<C::N>, u32)

Witness a variable. Should only be used when target is a gnark circuit.

§

WitnessFelt(Felt<C::F>, u32)

Witness a field element. Should only be used when target is a gnark circuit.

§

WitnessExt(Ext<C::F, C::EF>, u32)

Witness an extension field element. Should only be used when target is a gnark circuit.

§

Commit(Felt<C::F>, Var<C::N>)

Label a field element as the ith public input.

§

RegisterPublicValue(Felt<C::F>)

Registers a field element to the public inputs.

§

Halt

Operation to halt the program. Should be the last instruction in the program.

§

CircuitCommitVkeyHash(Var<C::N>)

Asserts that the inputted var is equal the circuit’s vkey hash public input. Should only be used when target is a gnark circuit.

§

CircuitCommitCommitedValuesDigest(Var<C::N>)

Asserts that the inputted var is equal the circuit’s commited values digest public input. Should only be used when target is a gnark circuit.

§

FriFold(Var<C::N>, Array<C, FriFoldInput<C>>)

Executes a FRI fold operation. 1st field is the size of the fri fold input array. 2nd field is the fri fold input array. See FriFoldInput for more details.

§

CircuitSelectV(Var<C::N>, Var<C::N>, Var<C::N>, Var<C::N>)

Select’s a variable based on a condition. (select(cond, true_val, false_val) => output). Should only be used when target is a gnark circuit.

§

CircuitSelectF(Var<C::N>, Felt<C::F>, Felt<C::F>, Felt<C::F>)

Select’s a field element based on a condition. (select(cond, true_val, false_val) => output). Should only be used when target is a gnark circuit.

§

CircuitSelectE(Var<C::N>, Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Select’s an extension field element based on a condition. (select(cond, true_val, false_val) => output). Should only be used when target is a gnark circuit.

§

CircuitExt2Felt([Felt<C::F>; 4], Ext<C::F, C::EF>)

Converts an ext to a slice of felts. Should only be used when target is a gnark circuit.

§

CircuitFelts2Ext([Felt<C::F>; 4], Ext<C::F, C::EF>)

Converts a slice of felts to an ext. Should only be used when target is a gnark circuit.

§

LessThan(Var<C::N>, Var<C::N>, Var<C::N>)

Executes less than (var = var < var). This operation is NOT constrained.

§

CycleTracker(String)

Tracks the number of cycles used by a block of code annotated by the string input.

§

ExpReverseBitsLen(Ptr<C::N>, Var<C::N>, Var<C::N>)

Trait Implementations§

source§

impl<C: Clone + Config> Clone for DslIr<C>
where C::N: Clone, C::F: Clone, C::EF: Clone,

source§

fn clone(&self) -> DslIr<C>

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<C: Debug + Config> Debug for DslIr<C>
where C::N: Debug, C::F: Debug, C::EF: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<C> Freeze for DslIr<C>
where <C as Config>::N: Freeze, <C as Config>::F: Freeze, <C as Config>::EF: Freeze,

§

impl<C> RefUnwindSafe for DslIr<C>
where <C as Config>::N: RefUnwindSafe, <C as Config>::F: RefUnwindSafe, <C as Config>::EF: RefUnwindSafe,

§

impl<C> Send for DslIr<C>

§

impl<C> Sync for DslIr<C>

§

impl<C> Unpin for DslIr<C>
where <C as Config>::N: Unpin, <C as Config>::F: Unpin, <C as Config>::EF: Unpin,

§

impl<C> UnwindSafe for DslIr<C>
where <C as Config>::N: UnwindSafe, <C as Config>::F: UnwindSafe, <C as Config>::EF: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> Conv for T

source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
source§

impl<T> Downcast for T
where T: Any,

source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<F, EF, E> ExtensionOperand<F, EF> for E
where F: Field, EF: ExtensionField<F>, E: Any,

source§

fn to_operand(self) -> ExtOperand<F, EF>

source§

impl<T> FmtForward for T

source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Pipe for T
where T: ?Sized,

source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> Tap for T

source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> TryConv for T

source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> JsonSchemaMaybe for T