Enum koto_parser::Node

pub enum Node {
    Empty,
    Id(ConstantIndex),
    Lookup((LookupNode, Option<AstIndex>)),
    BoolTrue,
    BoolFalse,
    Number0,
    Number1,
    Int(ConstantIndex),
    Float(ConstantIndex),
    Str(ConstantIndex),
    Num2(Vec<AstIndex>),
    Num4(Vec<AstIndex>),
    List(Vec<AstIndex>),
    Tuple(Vec<AstIndex>),
    TempTuple(Vec<AstIndex>),
    Range {
        start: AstIndex,
        end: AstIndex,
        inclusive: bool,
    },
    RangeFrom {
        start: AstIndex,
    },
    RangeTo {
        end: AstIndex,
        inclusive: bool,
    },
    RangeFull,
    Map(Vec<(ConstantIndex, Option<AstIndex>)>),
    MainBlock {
        body: Vec<AstIndex>,
        local_count: usize,
    },
    Block(Vec<AstIndex>),
    Function(Function),
    Call {
        function: AstIndex,
        args: Vec<AstIndex>,
    },
    Import {
        from: Vec<ConstantIndex>,
        items: Vec<Vec<ConstantIndex>>,
    },
    Assign {
        target: AssignTarget,
        op: AssignOp,
        expression: AstIndex,
    },
    MultiAssign {
        targets: Vec<AssignTarget>,
        expression: AstIndex,
    },
    BinaryOp {
        op: AstOp,
        lhs: AstIndex,
        rhs: AstIndex,
    },
    If(AstIf),
    Match {
        expression: Option<AstIndex>,
        arms: Vec<MatchArm>,
    },
    Wildcard,
    Ellipsis(Option<ConstantIndex>),
    For(AstFor),
    Loop {
        body: AstIndex,
    },
    While {
        condition: AstIndex,
        body: AstIndex,
    },
    Until {
        condition: AstIndex,
        body: AstIndex,
    },
    Break,
    Continue,
    Return,
    ReturnExpression(AstIndex),
    Negate(AstIndex),
    Try(AstTry),
    Yield(AstIndex),
    Debug {
        expression_string: ConstantIndex,
        expression: AstIndex,
    },
}

Variants

Empty

Id(ConstantIndex)

Lookup((LookupNode, Option<AstIndex>))

BoolTrue

BoolFalse

Number0

Number1

Int(ConstantIndex)

Float(ConstantIndex)

Str(ConstantIndex)

Num2(Vec<AstIndex>)

Num4(Vec<AstIndex>)

List(Vec<AstIndex>)

Tuple(Vec<AstIndex>)

TempTuple(Vec<AstIndex>)

Range

Fields of Range

start: AstIndexend: AstIndexinclusive: bool

RangeFrom

Fields of RangeFrom

start: AstIndex

RangeTo

Fields of RangeTo

end: AstIndexinclusive: bool

RangeFull

Map(Vec<(ConstantIndex, Option<AstIndex>)>)

MainBlock

Fields of MainBlock

body: Vec<AstIndex>local_count: usize

Block(Vec<AstIndex>)

Function(Function)

Call

Fields of Call

function: AstIndexargs: Vec<AstIndex>

Import

Fields of Import

from: Vec<ConstantIndex>items: Vec<Vec<ConstantIndex>>

Assign

Fields of Assign

target: AssignTargetop: AssignOpexpression: AstIndex

MultiAssign

Fields of MultiAssign

targets: Vec<AssignTarget>expression: AstIndex

BinaryOp

Fields of BinaryOp

op: AstOplhs: AstIndexrhs: AstIndex

If(AstIf)

Match

Fields of Match

expression: Option<AstIndex>arms: Vec<MatchArm>

Wildcard

Ellipsis(Option<ConstantIndex>)

For(AstFor)

Loop

Fields of Loop

body: AstIndex

While

Fields of While

condition: AstIndexbody: AstIndex

Until

Fields of Until

condition: AstIndexbody: AstIndex

Break

Continue

Return

ReturnExpression(AstIndex)

Negate(AstIndex)

Try(AstTry)

Yield(AstIndex)

Debug

Fields of Debug

expression_string: ConstantIndexexpression: AstIndex

Trait Implementations

impl Clone for Node

pub fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Default for Node

pub fn default() -> Self

Returns the "default value" for a type.

impl Display for Node

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

Formats the value using the given formatter.

impl PartialEq<Node> for Node

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

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

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

This method tests for !=.

impl StructuralPartialEq for Node