Struct Clause 

pub struct Clause {
    pub vars: Vec<String>,
    pub source: ClauseSource,
}

One clause of a comprehension: one or more variable names paired with their source expression(s).

Single-var clause (the common case): one variable binds successive values from one source list. Clause::new("k", "1..10") is the construction shortcut.

Parallel clause (SRD-18c Layer 7a): multiple variables advance in lockstep (“zip”) from multiple source expressions. Clause::parallel(["x", "y"], ["1..10", "100..1000..100"]) builds the parallel form.

The string fields are owned because the AST gets stored on long-lived scope-tree / scenario-tree nodes; sharing references back into the source text would force lifetimes through every consumer.

Fields

vars: Vec<String>

The element names the clause binds.

source: ClauseSource

Where the values come from.

Implementations

impl Clause

pub fn new(var: impl Into<String>, expr: impl Into<String>) -> Clause

Single-var construction: Clause::new("k", "1..10"). Backward-compatible with the pre-Layer-7a shape — every existing call site works unchanged.

pub fn parallel( vars: impl IntoIterator<Item = impl Into<String>>, exprs: impl IntoIterator<Item = impl Into<String>>, ) -> Clause

Parallel-iter construction (SRD-18c Layer 7a): Clause::parallel(["x", "y"], ["1..10", "fib(8)"]). Defaults to ZipMode::Strict — length mismatch across the parallel group is an iteration-time error. Use Clause::parallel_with_mode to opt into truncate / cycle.

Length mismatch between vars and exprs is a programming error and panics — the parser’s input validation should catch malformed user input before it reaches this constructor.

pub fn parallel_with_mode( mode: ZipMode, vars: impl IntoIterator<Item = impl Into<String>>, exprs: impl IntoIterator<Item = impl Into<String>>, ) -> Clause

Parallel-iter construction with explicit zip mode. See ZipMode.

pub fn single_var(&self) -> Option<&str>

Single-var convenience: returns the lone variable name when the clause is single-var. None for parallel-iter forms — those have multiple names.

pub fn single_expr(&self) -> Option<&str>

Single-source convenience: returns the lone source expression when the clause uses ClauseSource::Single. None for parallel forms.

pub fn is_parallel(&self) -> bool

True for parallel-iter clauses (Layer 7a).

pub fn first_var(&self) -> &str

Backward-compat accessor: returns the first variable name regardless of clause shape. Single-var clauses have vars.len() == 1; parallel clauses have ≥ 2. Most existing callers operate on single-var clauses and treat parallel forms as either-or — those should migrate to single_var() for explicit handling.

pub fn var(&self) -> &str

Convenience for single-var clauses (the historical common case): the lone variable name. For parallel clauses, returns the first variable’s name. Most existing call sites treat clauses as single-var; this keeps them working with a one-line c.var → c.var() migration.

pub fn expr(&self) -> &str

Convenience for single-source clauses: the lone source-expression text. For parallel clauses, returns the first expression — single-var-assuming callers see the same shape they did before Layer 7a.

pub fn scalar_bindings(&self) -> Vec<(&str, &str)>

Flatten this clause to its scalar (var, expr) pairs.

• Single-var (vars = [v], Single(s)): returns [(v, s)].
• Parallel-iter (vars = [v0, v1, ...], Parallel { exprs: [e0, e1, ...], .. }): returns [(v0, e0), (v1, e1), ...].

One canonical place to expand the var↔expr mapping — previously open-coded at three callers (synthesis representative-vars expansion, runner canonical-input declaration, runner param-ref scan).

Trait Implementations

impl Clone for Clause

fn clone(&self) -> Clause

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Clause

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Clause

fn deserialize<__D>( __deserializer: __D, ) -> Result<Clause, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Clause

Canonical text rendering of a clause:

• Single-var: var in expr.
• Parallel-iter: (a, b) in (e1, e2) for ZipMode::Strict, zip_truncate(...) / zip_cycle(...) for the other modes.

parse_clause(&clause.to_string()) round-trips back to the same AST.

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

Formats the value using the given formatter.

impl Eq for Clause

impl PartialEq for Clause

fn eq(&self, other: &Clause) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Clause

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Clause