Struct WitnessFolder

struct WitnessFolder<S, A> {
    state: S,
    accumulate: A,
}

Fold all witnesses in a circuit.

Fields

state: S

accumulate: A

Implementations

impl<S, A> WitnessFolder<S, A>

where A: Fn(&mut S, Witness),

fn new(init: S, accumulate: A) -> Self

Create the folder with some initial state and an accumulator function.

fn into_state(self) -> S

Take the accumulated state.

fn fold_circuit<F: AcirField>(&mut self, circuit: &Circuit<F>)

Add all witnesses from the circuit.

fn fold(&mut self, witness: Witness)

Fold a witness into the state.

fn fold_many<'w, I: Iterator<Item = &'w Witness>>(&mut self, witnesses: I)

Fold many witnesses into the state.

fn fold_opcode<F: AcirField>(&mut self, opcode: &Opcode<F>)

Add witnesses from the opcode.

fn fold_expr<F: AcirField>(&mut self, expr: &Expression<F>)

fn fold_brillig_inputs<F: AcirField>(&mut self, inputs: &[BrilligInputs<F>])

fn fold_brillig_outputs(&mut self, outputs: &[BrilligOutputs])

fn fold_blackbox<F: AcirField>(&mut self, call: &BlackBoxFuncCall<F>)

fn fold_inputs<F: AcirField>(&mut self, inputs: &[FunctionInput<F>])

fn fold_input<F: AcirField>(&mut self, input: &FunctionInput<F>)