Enum ChainNode 

pub enum ChainNode {
    Root(AstIndex),
    Id(ConstantIndex),
    Str(AstString),
    Index(AstIndex),
    Call {
        args: AstVec<AstIndex>,
        with_parens: bool,
    },
    NullCheck,
}

A node in a chained expression

Chains are any expressions that contain two or more nodes in a sequence.

In other words, some series of operations involving indexing, . accesses, and function calls.

e.g. foo.bar."baz"[0]?(42) | | | | |^ Call {args: 42, with_parens: true} | | | | ^ NullCheck | | | ^ Index (0) | | ^ Str (baz) | ^ Id (bar) ^ Root (foo)

Variants

Root(AstIndex)

The root of the chain

Id(ConstantIndex)

A . access using an identifier

Str(AstString)

A . access using a string

Index(AstIndex)

An index operation using square [] brackets.

Call

A function call

Fields

args: AstVec<AstIndex>

The arguments used in the function call

with_parens: bool

Whether or not parentheses are present in the function call

This is not cosmetic, as parentheses represent a ‘closed call’, which has an impact on function piping: e.g. 99 -> foo.bar 42 is equivalent to foo.bar(42, 99) but: 99 -> foo.bar(42) is equivalent to foo.bar(42)(99).

NullCheck

A ? short-circuiting null check

Trait Implementations

impl Clone for ChainNode

fn clone(&self) -> ChainNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChainNode

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

Formats the value using the given formatter.

impl PartialEq for ChainNode

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

impl StructuralPartialEq for ChainNode