Enum Op 

pub enum Op {
    PushClause {
        name: String,
        source: Source,
    },
    Cartesian {
        n: usize,
    },
    Zip {
        n: usize,
        mode: ZipMode,
    },
    Union {
        n: usize,
    },
    Filter {
        predicate: String,
    },
    OrderStreaming {
        kind: OrderStreamingKind,
        truncation: Option<u64>,
    },
    OrderMaterialize {
        strategy: StrategyName,
        truncation: Option<u64>,
        indexed: bool,
        input_index_fn: Option<IndexFn>,
    },
    Dispense,
}

The 8-opcode IR set (spec §9.1).

Variants

PushClause

Push a single-name tuple stream produced by source. Streaming; O(1) per pull above the source’s own state.

Fields

name: String

The name the stream binds.

source: Source

Where its values come from.

Cartesian

Replace the top-N stream operands with one stream that enumerates their cross product in Lex order. Streaming.

Fields

n: usize

Operands combined.

Zip

Replace the top-N stream operands with their lockstep diagonal. Streaming under Strict/Truncate; Cycle buffers each non-longest child.

Fields

n: usize

Operands combined.

mode: ZipMode

The length policy.

Union

Replace the top-N stream operands with a stream that concatenates them in operand order. Streaming.

Fields

n: usize

Operands concatenated.

Filter

Wrap the top operand with a per-tuple predicate check. Streaming.

Fields

predicate: String

The predicate, a boolean expression over the tuple.

OrderStreaming

Wrap the top operand with a counter / pass-through. Used for order(Lex, _) per spec §10.2 R1; this is the “streaming” order opcode.

Fields

kind: OrderStreamingKind

The streaming order’s kind.

truncation: Option<u64>

The output cap, if any.

OrderMaterialize

MATERIALIZATION BARRIER. Build a working set sufficient for the strategy, apply the strategy, emit permuted tuples. Truncation is the output cap.

Per spec §10.2 R2: when the input is index-addressable and the strategy has a closed-form push-down rule, the working set shrinks from O(input) to O(output) — the interpreter realizes this by drawing strategy-specific multi-indices and looking each up against the input’s IndexFn rather than materializing the full input. Whether R2 fires is encoded in indexed.

input_index_fn carries the upstream comprehension’s addressing scheme (per spec §10.7.6 / §10.7.8) so the strategy’s indexed-form algorithms can dispatch correctly without re-deriving the shape from observed tuples (which would lose multi-axis lattice structure after the flat materialization). None when the upstream metadata propagator couldn’t claim a closed- form addressing function.

Fields

strategy: StrategyName

The strategy applied.

truncation: Option<u64>

The output cap, if any.

indexed: bool

true when R2 push-down applies: the interpreter should use the strategy’s indexed form (draw multi-indices, look up via input IndexFn). false for the naïve form (materialize input, then apply).

input_index_fn: Option<IndexFn>

Upstream input’s IndexFn at compile time (spec §10.7.6). The interpreter passes this into the crate::iteration::comprehension::strategies::EvaluatedInput it builds for crate::iteration::comprehension::strategies::Strategy::apply.

Dispense

Bind the top stream as the comprehension’s result. Must be the last opcode in a well-formed Program.

Implementations

impl Op

pub fn stack_effect(&self) -> (usize, usize)

Arity for stack-effect computation: how many stream operands this opcode pops, and how many it pushes. Always pushes 1 for stream-producing ops; Dispense pushes 0 (it consumes the final stream).

pub fn is_barrier(&self) -> bool

true if this opcode is a materialization barrier per spec §6.2 + §6.3. Used by the bounds checker.

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Op

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Op

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Op

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Op