Enum PipeOp 

pub enum PipeOp {
    Transform(Box<Expr>),
    Filter(Box<Expr>),
    Sort(Option<Ident>),
    Reduce(Box<Expr>),
    Middle,
    Choice,
    Nth(Box<Expr>),
    Next,
    First,
    Last,
    Parallel(Box<PipeOp>),
    Gpu(Box<PipeOp>),
    Method {
        name: Ident,
        args: Vec<Expr>,
    },
    Await,
    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>>,
    },
}

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}

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

Fields

name: Ident

args: Vec<Expr>

Await

Await

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>>

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