Enum koto_parser::LookupNode

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

A node in a lookup chain

Lookups are any expressions that access a values from identifiers, and then as the lookup chain continues, from any following temporary results.

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} | | | ^ Index (0) | | ^ Str (baz) | ^ Id (bar) ^ Root (foo)

Variants

Root(AstIndex)

Tuple Fields

0: AstIndex

The root of the lookup chain

Id(ConstantIndex)

Tuple Fields

0: ConstantIndex

A . access using an identifier

Str(AstString)

Tuple Fields

0: AstString

A . access using a string

Index(AstIndex)

Tuple Fields

0: AstIndex

An index operation using square [] brackets.

Call

Fields

args: Vec<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).

A function call

Trait Implementations

impl Clone for LookupNode

fn clone(&self) -> LookupNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LookupNode

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

Formats the value using the given formatter.

impl PartialEq<LookupNode> for LookupNode

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for LookupNode