Enum PipeOp 

pub enum PipeOp {
    Transform(Box<Expr>),
    Filter(Box<Expr>),
    Sort(Option<Ident>),
    Reduce(Box<Expr>),
    ReduceSum,
    ReduceProd,
    ReduceMin,
    ReduceMax,
    ReduceConcat,
    ReduceAll,
    ReduceAny,
    Middle,
    Choice,
    Nth(Box<Expr>),
    Next,
    First,
    Last,
    Parallel(Box<PipeOp>),
    Gpu(Box<PipeOp>),
    Method {
        name: Ident,
        type_args: Option<Vec<TypeExpr>>,
        args: Vec<Expr>,
    },
    Call(Box<Expr>),
    Await,
    Match(Vec<MatchArm>),
    TryMap(Option<Box<Expr>>),
    Named {
        prefix: Vec<Ident>,
        body: Option<Box<Expr>>,
    },
    Send(Box<Expr>),
    Recv,
    Stream(Box<Expr>),
    Connect(Option<Box<Expr>>),
    Close,
    Header {
        name: Box<Expr>,
        value: Box<Expr>,
    },
    Body(Box<Expr>),
    Timeout(Box<Expr>),
    Retry {
        count: Box<Expr>,
        strategy: Option<Box<Expr>>,
    },
    Validate {
        predicate: Box<Expr>,
        target_evidence: Evidentiality,
    },
    Assume {
        reason: Option<Box<Expr>>,
        target_evidence: Evidentiality,
    },
    AssertEvidence(Evidentiality),
    Also(Box<Expr>),
    Apply(Box<Expr>),
    TakeIf(Box<Expr>),
    TakeUnless(Box<Expr>),
    Let(Box<Expr>),
    All(Box<Expr>),
    Any(Box<Expr>),
    Compose(Box<Expr>),
    Zip(Box<Expr>),
    Scan(Box<Expr>),
    Diff,
    Gradient(Box<Expr>),
    SortAsc,
    SortDesc,
    Reverse,
    Cycle(Box<Expr>),
    Windows(Box<Expr>),
    Chunks(Box<Expr>),
    Flatten,
    Unique,
    Enumerate,
    Universal,
    Possibility,
    PossibilityMethod {
        name: Ident,
        args: Vec<Expr>,
    },
    Necessity,
    NecessityMethod {
        name: Ident,
        args: Vec<Expr>,
    },
}

Pipe operation in a chain.

Variants

Transform(Box<Expr>)

Transform morpheme: τ{f}

Filter(Box<Expr>)

Filter morpheme: φ{p}

Sort(Option<Ident>)

Sort morpheme: σ or σ.field

Reduce(Box<Expr>)

Reduce morpheme: ρ{f}

ReduceSum

Sum reduction: ρ+ or ρ_sum - sum all elements

ReduceProd

Product reduction: ρ* or ρ_prod - multiply all elements

ReduceMin

Min reduction: ρ_min - find minimum element

ReduceMax

Max reduction: ρ_max - find maximum element

ReduceConcat

Concat reduction: ρ++ or ρ_cat - concatenate strings/arrays

ReduceAll

All reduction: ρ& or ρ_all - logical AND (all true)

ReduceAny

Any reduction: ρ| or ρ_any - logical OR (any true)

Middle

Middle morpheme: μ - get middle/median element

Choice

Choice morpheme: χ - random element selection

Nth(Box<Expr>)

Nth morpheme: ν{n} - get nth element

Next

Next morpheme: ξ - get next element (iterator)

First

First morpheme: α - get first element

Last

Last morpheme: ω - get last element

Parallel(Box<PipeOp>)

Parallel morpheme: ∥{op} or parallel{op} - execute operation in parallel Wraps another operation to run it across multiple threads

Gpu(Box<PipeOp>)

GPU compute morpheme: ⊛{op} or gpu{op} - execute operation on GPU Wraps another operation to run it as a compute shader

Method

Method call with optional turbofish type arguments: |collect::<String>()

Fields

name: Ident

type_args: Option<Vec<TypeExpr>>

args: Vec<Expr>

Call(Box<Expr>)

Call an arbitrary expression (e.g., |self.layer where layer is a callable)

Await

Await

Match(Vec<MatchArm>)

Match morpheme: |match{ Pattern => expr, ... } Applies pattern matching to the piped value

TryMap(Option<Box<Expr>>)

Trust boundary morpheme: |‽ or |‽{mapper} Uses interrobang (‽) to signal crossing a trust/certainty boundary. Unwraps Result/Option or propagates errors, with optional error transformation.

Named

Named morpheme: ·map{f}, ·flow{f}

Fields

prefix: Vec<Ident>

body: Option<Box<Expr>>

Send(Box<Expr>)

Send operation: |send{data} or |⇒{data} - send data over connection Results are automatically marked with Reported evidentiality

Recv

Receive operation: |recv or |⇐ - receive data from connection Results are automatically marked with Reported evidentiality

Stream(Box<Expr>)

Stream operation: |stream{handler} or |≋{handler} - iterate over incoming data Each element is marked with Reported evidentiality

Connect(Option<Box<Expr>>)

Connect operation: |connect{config} or |⊸{config} - establish connection

Close

Close operation: |close or |⊗ - close connection gracefully

Header

Protocol header: |header{name, value} - add/set header

Fields

name: Box<Expr>

value: Box<Expr>

Body(Box<Expr>)

Protocol body: |body{data} - set request body

Timeout(Box<Expr>)

Timeout: |timeout{ms} or |⏱{ms} - set operation timeout

Retry

Retry: |retry{count} or |retry{count, strategy} - retry on failure

Fields

count: Box<Expr>

strategy: Option<Box<Expr>>

Validate

Validate operation: |validate!{predicate} - promote evidence with validation Takes a predicate function that validates the data. If validation passes: ~ → ! (reported → known) If validation fails: returns an error Example: data~|validate!{x => x.id > 0 && x.name.len > 0}

Fields

predicate: Box<Expr>

target_evidence: Evidentiality

Assume

Assume operation: |assume! or |assume!("reason") - explicit trust promotion Escape hatch that promotes evidence with an audit trail. Always logs the assumption for security review. Example: external_data~|assume!("trusted legacy system")

Fields

reason: Option<Box<Expr>>

target_evidence: Evidentiality

AssertEvidence(Evidentiality)

Assert evidence: |assert_evidence!{expected} - verify evidence level at compile time Fails compilation if actual evidence doesn’t match expected. Example: data|assert_evidence!{!} - assert data is known

Also(Box<Expr>)

Also: |also{f} - execute side effect, return original value unchanged Like Kotlin’s also - useful for logging/debugging in pipelines Example: data|also{println}|process - logs data, then processes it

Apply(Box<Expr>)

Apply: |apply{block} - mutate value in place, return modified value Like Kotlin’s apply - useful for configuration/setup Example: config|apply{.timeout = 5000; .retries = 3}

TakeIf(Box<Expr>)

TakeIf: |take_if{predicate} - return Some(value) if predicate true, None otherwise Like Kotlin’s takeIf - useful for conditional pipelines Example: user|take_if{.age >= 18} - returns Option

TakeUnless(Box<Expr>)

TakeUnless: |take_unless{predicate} - return Some(value) if predicate false Like Kotlin’s takeUnless - inverse of take_if Example: item|take_unless{.is_deleted} - returns Option

Let(Box<Expr>)

Let: |let{f} - transform value, like map but reads better for single values Like Kotlin’s let - essentially an alias for transform Example: name|let{.to_uppercase} - transforms the name

All(Box<Expr>)

All/ForAll: |∀{p} or |all{p} - check if ALL elements satisfy predicate Returns bool. Short-circuits on first false. Example: numbers|∀{x => x > 0} - are all positive?

Any(Box<Expr>)

Any/Exists: |∃{p} or |any{p} - check if ANY element satisfies predicate Returns bool. Short-circuits on first true. Example: items|∃{.is_valid} - is any valid?

Compose(Box<Expr>)

Compose: |∘{f} or |compose{f} - function composition Creates a new function that applies f after the current transformation. Example: parse|∘{validate}|∘{save} - compose three functions

Zip(Box<Expr>)

Zip/Join: |⋈{other} or |zip{other} - combine with another collection Pairs elements from two collections into tuples. Example: names|⋈{ages} -> [(name1, age1), (name2, age2), …]

Scan(Box<Expr>)

Scan/Integral: |∫{f} or |scan{f} - cumulative fold (like Haskell’s scanl) Returns all intermediate accumulator values. Example: [1,2,3]|∫{+} -> [1, 3, 6] (running sum)

Diff

Diff/Derivative: |∂ or |diff - differences between adjacent elements Returns a collection of deltas. Example: [1, 4, 6, 10]|∂ -> [3, 2, 4]

Gradient(Box<Expr>)

Gradient: |∇{var} or |grad{var} - automatic differentiation Computes gradient of expression with respect to variable. Example: loss|∇{weights} - gradient for backprop

SortAsc

Sort Ascending: |⍋ or |sort_asc - APL grade-up Sorts in ascending order (same as σ but more explicit)

SortDesc

Sort Descending: |⍒ or |sort_desc - APL grade-down Sorts in descending order

Reverse

Reverse: |⌽ or |rev - APL rotate/reverse Reverses the collection

Cycle(Box<Expr>)

Cycle: |↻{n} or |cycle{n} - repeat collection n times Example: [1,2]|↻{3} -> [1,2,1,2,1,2]

Windows(Box<Expr>)

Windows: |⌺{n} or |windows{n} - sliding window Example: [1,2,3,4]|⌺{2} -> [[1,2], [2,3], [3,4]]

Chunks(Box<Expr>)

Chunks: |⊞{n} or |chunks{n} - split into chunks Example: [1,2,3,4]|⊞{2} -> [[1,2], [3,4]]

Flatten

Flatten: |⋳ or |flatten - flatten nested collection Example: [[1,2], [3,4]]|⋳ -> [1,2,3,4]

Unique

Unique: |∪ or |unique - remove duplicates (set union with self) Example: [1,2,2,3,3,3]|∪ -> [1,2,3]

Enumerate

Enumerate: |⍳ or |enumerate - APL iota, pair with indices Example: ["a","b","c"]|⍳ -> [(0,“a”), (1,“b”), (2,“c”)]

Universal

Universal reconstruction: |∀ - reconstruct whole from shards For Vec: sums all elements (numeric reconstruction) For distributed data: merges fragments into coherent whole Example: vec![1, 2, 3, 4]|∀ -> 10

Possibility

Possibility extraction: |◊ - extract approximate/speculative answer For uncertain data: returns best-effort approximation Preserves uncertainty markers in output Example: uncertain_data|◊ -> approximate value

PossibilityMethod

Possibility method call: |◊method or |◊method(args) Calls method with possibility semantics (returns approximate result) Example: hll|◊count -> approximate cardinality

Fields

name: Ident

args: Vec<Expr>

Necessity

Necessity verification: |□ - verify and promote to certain Validates data meets requirements, promotes evidence level Fails if verification cannot be established Example: data|□ -> verified data with ! evidentiality

NecessityMethod

Necessity method call: |□method or |□method(args) Calls method with necessity semantics (verifies and promotes evidence) Example: node~|□verify -> verified with ! evidentiality

Fields

name: Ident

args: Vec<Expr>

Trait Implementations

impl Clone for PipeOp

fn clone(&self) -> PipeOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PipeOp

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

Formats the value using the given formatter.

impl PartialEq for PipeOp

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for PipeOp