Enum Query 

pub enum Query {
    Term(Box<Term>),
    WithFunc {
        function: FuncDef,
        query: Box<Query>,
    },
    Pipe {
        lhs: Box<Query>,
        rhs: Box<Query>,
    },
    Concat {
        lhs: Box<Query>,
        rhs: Box<Query>,
    },
    Bind {
        source: Box<Term>,
        patterns: Vec<BindPattern>,
        body: Box<Query>,
    },
    Reduce {
        source: Box<Term>,
        pattern: BindPattern,
        initial: Box<Query>,
        accumulator: Box<Query>,
    },
    ForEach {
        source: Box<Term>,
        pattern: BindPattern,
        initial: Box<Query>,
        update: Box<Query>,
        extract: Option<Box<Query>>,
    },
    If {
        cond: Box<Query>,
        positive: Box<Query>,
        negative: Option<Box<Query>>,
    },
    Try {
        body: Box<Query>,
        catch: Option<Box<Query>>,
    },
    Label {
        label: Identifier,
        body: Box<Query>,
    },
    Operate {
        lhs: Box<Query>,
        operator: BinaryOp,
        rhs: Box<Query>,
    },
    Update {
        lhs: Box<Query>,
        operator: UpdateOp,
        rhs: Box<Query>,
    },
    Compare {
        lhs: Box<Query>,
        comparator: Comparator,
        rhs: Box<Query>,
    },
}

Variants

Term(Box<Term>)

<term> | <query> '?'

WithFunc

'def' <ident> ( '(' <ident> | <var> (';' <ident> | <var>)* ')' )? ':' <query> ';' <query>

Fields

function: FuncDef

query: Box<Query>

Pipe

<query> ('|' <query>)+

Fields

lhs: Box<Query>

rhs: Box<Query>

Concat

<query> (',' <query>)+

Fields

lhs: Box<Query>

rhs: Box<Query>

Bind

<term> 'as' <pattern> ('?//' <pattern>)* '|' <query>

Fields

source: Box<Term>

patterns: Vec<BindPattern>

body: Box<Query>

Reduce

'reduce' <term> 'as' <pattern> '(' <query> ';' <query> ')'

Fields

source: Box<Term>

pattern: BindPattern

initial: Box<Query>

accumulator: Box<Query>

ForEach

'foreach' <term> 'as' <pattern> '(' <query> ';' <query> (';' <query>)? ')'

Fields

source: Box<Term>

pattern: BindPattern

initial: Box<Query>

update: Box<Query>

extract: Option<Box<Query>>

If

'if' <query> 'then' <query> ('elif' <query> 'then' <query>)* ('else' <query>)? 'end'

Fields

cond: Box<Query>

positive: Box<Query>

negative: Option<Box<Query>>

Try

'try' <query> ('catch' <query>)?

Fields

body: Box<Query>

catch: Option<Box<Query>>

Label

'label' <variable> '|' <query>

Fields

label: Identifier

body: Box<Query>

Operate

<query> ('//' | '+' | '-' | '*' | '/' | '%' | 'and' | 'or') <query>

Fields

lhs: Box<Query>

operator: BinaryOp

rhs: Box<Query>

Update

<query> ('=' | '|=' | '//=' | '+=' | '-=' | '*=' | '/=' | '%=') <query>

Fields

lhs: Box<Query>

operator: UpdateOp

rhs: Box<Query>

Compare

<query> <comparator> <query>

Fields

lhs: Box<Query>

comparator: Comparator

rhs: Box<Query>

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Query

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

Formats the value using the given formatter.

impl From<Query> for Term

fn from(query: Query) -> Self

Converts to this type from the input type.

impl From<Term> for Query

fn from(term: Term) -> Self

Converts to this type from the input type.

impl PartialEq for Query

fn eq(&self, other: &Query) -> 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 Eq for Query

impl StructuralPartialEq for Query