Struct halo2_proofs::plonk::Constraints

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

A set of polynomial constraints with a common selector.

use halo2_middleware::poly::Rotation;
use halo2curves::pasta::Fp;

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, C, Iter> Constraints<F, C, Iter>

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

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

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, C, Iter> Debug for Constraints<F, C, Iter>

where F: Debug + Field, C: Debug + Into<Constraint<F>>, Iter: Debug + IntoIterator<Item = C>,

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

Formats the value using the given formatter.

impl<F, C, Iter> IntoIterator for Constraints<F, C, Iter>

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

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) -> <Constraints<F, C, Iter> as IntoIterator>::IntoIter

Creates an iterator from a value.