Struct halo2_proofs::plonk::Constraints

pub struct Constraints<F: Field, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> { /* private fields */ }

A set of polynomial constraints with a common selector.

use group::ff::Field;
use halo2_proofs::{pasta::Fp, plonk::{Constraints, Expression}, poly::Rotation};

let a = meta.advice_column();
let b = meta.advice_column();
let c = meta.advice_column();
let s = meta.selector();

meta.create_gate("foo", |meta| {
    let next = meta.query_advice(a, Rotation::next());
    let a = meta.query_advice(a, Rotation::cur());
    let b = meta.query_advice(b, Rotation::cur());
    let c = meta.query_advice(c, Rotation::cur());
    let s_ternary = meta.query_selector(s);

    let one_minus_a = Expression::Constant(Fp::ONE) - a.clone();

    Constraints::with_selector(
        s_ternary,
        std::array::IntoIter::new([
            ("a is boolean", a.clone() * one_minus_a.clone()),
            ("next == a ? b : c", next - (a * b + one_minus_a * c)),
        ]),
    )
});

Note that the use of std::array::IntoIter::new is only necessary if you need to support Rust 1.51 or 1.52. If your minimum supported Rust version is 1.53 or greater, you can pass an array directly.

Implementations

impl<F: Field, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> Constraints<F, C, Iter>

pub fn with_selector(selector: Expression<F>, constraints: Iter) -> Self

Constructs a set of constraints that are controlled by the given selector.

Each constraint c in iterator will be converted into the constraint selector * c.

Trait Implementations

impl<F: Debug + Field, C: Debug + Into<Constraint<F>>, Iter: Debug + IntoIterator<Item = C>> Debug for Constraints<F, C, Iter>

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

Formats the value using the given formatter.

impl<F: Field, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> IntoIterator for Constraints<F, C, Iter>

type Item = Constraint<F>

The type of the elements being iterated over.

type IntoIter = Map<Zip<Repeat<Expression<F>>, <Iter as IntoIterator>::IntoIter>, fn(_: (Expression<F>, C)) -> Constraint<F>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.