Enum Node 

pub enum Node<'ast> {
    Null,
    Bool(bool),
    Number(&'ast Number),
    String(&'ast str),
    StringChunks(&'ast [StringChunk<Ast<'ast>>]),
    Fun {
        args: &'ast [Pattern<'ast>],
        body: &'ast Ast<'ast>,
    },
    Let {
        bindings: &'ast [LetBinding<'ast>],
        body: &'ast Ast<'ast>,
        rec: bool,
    },
    App {
        head: &'ast Ast<'ast>,
        args: &'ast [Ast<'ast>],
    },
    Var(LocIdent),
    EnumVariant {
        tag: LocIdent,
        arg: Option<&'ast Ast<'ast>>,
    },
    Record(&'ast Record<'ast>),
    IfThenElse {
        cond: &'ast Ast<'ast>,
        then_branch: &'ast Ast<'ast>,
        else_branch: &'ast Ast<'ast>,
    },
    Match(Match<'ast>),
    Array(&'ast [Ast<'ast>]),
    PrimOpApp {
        op: &'ast PrimOp,
        args: &'ast [Ast<'ast>],
    },
    Annotated {
        annot: &'ast Annotation<'ast>,
        inner: &'ast Ast<'ast>,
    },
    Import(Import<'ast>),
    Type(&'ast Type<'ast>),
    ParseError(&'ast ParseError),
}

A node of the Nickel AST.

Nodes are built by the parser and then mostly traversed immutably. Such nodes are optimized for sharing (hence immutability) and for size, as the size of an enum can grow quite quickly in Rust. In particular, any data that is bigger than a few words isn’t usually owned but rather a reference to some arena-allocated data

Using an arena has another advantage: the data is allocated in the same order as the AST is built. This means that even if there are reference indirections, the children of a node are most likely close to the node itself in memory, which should be good for cache locality.

Variants

Null

The null value.

Bool(bool)

A boolean value.

Number(&'ast Number)

A number.

A number is an arbitrary-precision rational in Nickel. It’s not small and thus we put it behind a reference to avoid size bloat.

String(&'ast str)

A string literal.

StringChunks(&'ast [StringChunk<Ast<'ast>>])

A string containing interpolated expressions, represented as a list of either literals or expressions.

As opposed to nickel_lang_core::term::Term::StrChunks, the chunks are stored in the original order: "hello%{var}" will give ["hello", var].

Fun

A function.

Fields

args: &'ast [Pattern<'ast>]

body: &'ast Ast<'ast>

Let

A let block.

Fields

bindings: &'ast [LetBinding<'ast>]

body: &'ast Ast<'ast>

rec: bool

App

An application to one or more arguments.

Fields

head: &'ast Ast<'ast>

args: &'ast [Ast<'ast>]

Var(LocIdent)

A variable.

EnumVariant

An enum variant (an algebraic datatype).

Variants have at most one argument: variants with no arguments are often called simply enum tags. Note that one can just use a record as an argument to emulate variants with multiple arguments.

Fields

tag: LocIdent

arg: Option<&'ast Ast<'ast>>

Record(&'ast Record<'ast>)

A record.

IfThenElse

An if-then-else expression.

Fields

cond: &'ast Ast<'ast>

then_branch: &'ast Ast<'ast>

else_branch: &'ast Ast<'ast>

Match(Match<'ast>)

A match expression. This expression is still to be applied to an argument to match on.

Array(&'ast [Ast<'ast>])

An array.

PrimOpApp

An n-ary primitive operation application. As opposed to a traditional function application:

1. The function part is necessarily a primitive operation.
2. The arguments are forced before entering the

Fields

op: &'ast PrimOp

args: &'ast [Ast<'ast>]

Annotated

A term with a type and/or contract annotation.

Fields

annot: &'ast Annotation<'ast>

inner: &'ast Ast<'ast>

Import(Import<'ast>)

An import.

Type(&'ast Type<'ast>)

A type in term position, such as in let my_contract = Number -> Number in ....

During evaluation, this will get turned into a contract.

ParseError(&'ast ParseError)

A term that couldn’t be parsed properly. Used by the LSP to handle partially valid programs.

Implementations

impl<'ast> Node<'ast>

pub fn try_str_chunk_as_static_str(&self) -> Option<String>

Tries to extract a static literal from string chunks.

This methods returns a Some(..) when the term is a Node::StringChunks and all the chunks are StringChunk::Literal

pub fn spanned(self, pos: TermPos) -> Ast<'ast>

Attaches a position to this node turning it into an Ast.

Trait Implementations

impl<'ast> Clone for Node<'ast>

fn clone(&self) -> Node<'ast>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for Node<'_>

type Data<'a> = Node<'a>

This is always Self, be we need associated types to make Rust understand that Self is always parametric over the 'ast lifetime. We’re using GATs to emulate higher-kinded types.

fn clone_to<'to>(data: Node<'_>, dest: &'to AstAlloc) -> Node<'to>

Clones owned data from the current allocator to dest.

impl<'ast> Debug for Node<'ast>

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

Formats the value using the given formatter.

impl<'ast> Default for Node<'ast>

fn default() -> Node<'ast>

Returns the “default value” for a type.

impl Display for Node<'_>

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

Formats the value using the given formatter.

impl<'ast> From<Node<'ast>> for Ast<'ast>

fn from(node: Node<'ast>) -> Self

Converts to this type from the input type.

impl IsAtom for Node<'_>

fn is_atom(&self) -> bool

Determine if an expression is an atom of the surface syntax. Atoms are basic elements of the syntax that can freely substituted without being parenthesized.

impl<'ast> PartialEq for Node<'ast>

fn eq(&self, other: &Node<'ast>) -> 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<'a> Pretty<'a, Allocator> for &Node<'_>

fn pretty(self, allocator: &'a Allocator) -> DocBuilder<'a, Allocator>

Converts self into a document

impl Allocable for Node<'_>

impl<'ast> Eq for Node<'ast>

impl<'ast> StructuralPartialEq for Node<'ast>