Enum badder_lang::Ast

pub enum Ast {
    Num(Token, SourceRef),
    BinOp(Token, Box<Ast>, Box<Ast>, SourceRef),
    LeftUnaryOp(Token, Box<Ast>, SourceRef),
    Assign(Token, Box<Ast>, SourceRef),
    Reassign(Token, Box<Ast>, SourceRef),
    Refer(Token, SourceRef),
    If(Box<Ast>, Arc<Ast>, Option<Box<Ast>>, bool, SourceRef),
    While(Box<Ast>, Arc<Ast>, SourceRef),
    ForIn(Option<Token>, Token, Box<Ast>, Arc<Ast>, SourceRef),
    LoopNav(Token, SourceRef),
    AssignFun(Token, Vec<Token>, Arc<Ast>, SourceRef),
    Return(Box<Ast>, SourceRef),
    Call(Token, Vec<Ast>, SourceRef),
    Seq(Vec<Ast>, SourceRef),
    AssignSeq(Token, Box<Ast>, SourceRef),
    ReferSeq(Token, SourceRef),
    ReferSeqIndex(Token, Box<Ast>, SourceRef),
    ReassignSeqIndex(Token, Box<Ast>, Box<Ast>, SourceRef),
    Line(usize, Box<Ast>, SourceRef),
    LinePair(Box<Ast>, Box<Ast>, SourceRef),
    Empty(SourceRef),
}

Abstract syntax tree

Variants

Num(Token, SourceRef)

BinOp(Token, Box<Ast>, Box<Ast>, SourceRef)

LeftUnaryOp(Token, Box<Ast>, SourceRef)

Assign(Token, Box<Ast>, SourceRef)

Assign(variable_id, ast)

Reassign(Token, Box<Ast>, SourceRef)

Refer(Token, SourceRef)

Refer(variable_id)

If(Box<Ast>, Arc<Ast>, Option<Box<Ast>>, bool, SourceRef)

If(if-expr, resultant-block, Line(If), is_else)

While(Box<Ast>, Arc<Ast>, SourceRef)

While(if-expr, resultant-block)

ForIn(Option<Token>, Token, Box<Ast>, Arc<Ast>, SourceRef)

ForIn(index-id, item-id, list, block)

LoopNav(Token, SourceRef)

LoopNav(break|continue)

AssignFun(Token, Vec<Token>, Arc<Ast>, SourceRef)

AssignFun(function-id, args, block) defines a function

Return(Box<Ast>, SourceRef)

Call(Token, Vec<Ast>, SourceRef)

Call(function-id, args)

Seq(Vec<Ast>, SourceRef)

Literal sequence of expressions

AssignSeq(Token, Box<Ast>, SourceRef)

AssignSeq(seq-id, Seq)

ReferSeq(Token, SourceRef)

ReferSeq(seq-id) refer to a sequence

ReferSeqIndex(Token, Box<Ast>, SourceRef)

ReferSeqIndex(seq-id, index)

ReassignSeqIndex(Token, Box<Ast>, Box<Ast>, SourceRef)

ReassignSeqIndex(seq-id, index, val)

Line(usize, Box<Ast>, SourceRef)

Line(scope, expr)

LinePair(Box<Ast>, Box<Ast>, SourceRef)

LinePair(line, next_line)

Empty(SourceRef)

Implementations

impl Ast

pub fn bin_op<A: Into<Box<Ast>>>(token: Token, left: A, right: A) -> Ast

pub fn line_pair<A: Into<Box<Ast>>>(before: A, after: A) -> Ast

pub fn just_if(expr: Ast, block: Ast, is_else: bool, if_start: SourceRef) -> Ast

pub fn if_else(
    expr: Ast,
    block: Ast,
    else_if: Ast,
    is_else: bool,
    if_start: SourceRef
) -> Ast

pub fn num(n: Int, src: SourceRef) -> Ast

pub fn debug_string(&self) -> String

pub fn src(&self) -> SourceRef

Trait Implementations

impl Clone for Ast

fn clone(&self) -> Ast

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ast

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

Safe for large recursive structures

impl Hash for Ast

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Ast> for Ast

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

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

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

This method tests for !=.

impl StructuralPartialEq for Ast