Enum Card

pub enum Card {
    Add(BinaryExpression),
    Sub(BinaryExpression),
    Mul(BinaryExpression),
    Div(BinaryExpression),
    Less(BinaryExpression),
    LessOrEq(BinaryExpression),
    Equals(BinaryExpression),
    NotEquals(BinaryExpression),
    And(BinaryExpression),
    Or(BinaryExpression),
    Xor(BinaryExpression),
    Not(UnaryExpression),
    Return(UnaryExpression),
    ScalarNil,
    CreateTable,
    Abort,
    Len(UnaryExpression),
    SetProperty(Box<[Card; 3]>),
    GetProperty(BinaryExpression),
    ScalarInt(i64),
    ScalarFloat(f64),
    StringLiteral(String),
    CallNative(Box<CallNode>),
    IfTrue(BinaryExpression),
    IfFalse(BinaryExpression),
    IfElse(Box<[Card; 3]>),
    Call(Box<StaticJump>),
    Function(String),
    NativeFunction(String),
    SetGlobalVar(Box<SetVar>),
    SetVar(Box<SetVar>),
    ReadVar(VarName),
    Repeat(Box<Repeat>),
    While(Box<[Card; 2]>),
    ForEach(Box<ForEach>),
    CompositeCard(Box<CompositeCard>),
    DynamicCall(Box<DynamicJump>),
    Get(BinaryExpression),
    AppendTable(BinaryExpression),
    PopTable(UnaryExpression),
    Array(Vec<Card>),
    Closure(Box<Function>),
    Comment(String),
}

Cao-Lang AST

Variants

Add(BinaryExpression)

Sub(BinaryExpression)

Mul(BinaryExpression)

Div(BinaryExpression)

Less(BinaryExpression)

LessOrEq(BinaryExpression)

Equals(BinaryExpression)

NotEquals(BinaryExpression)

And(BinaryExpression)

Or(BinaryExpression)

Xor(BinaryExpression)

Not(UnaryExpression)

Return(UnaryExpression)

ScalarNil

CreateTable

Abort

Len(UnaryExpression)

SetProperty(Box<[Card; 3]>)

Insert value at key into the table [Value, Table, Key]

GetProperty(BinaryExpression)

[Table, Key]

ScalarInt(i64)

ScalarFloat(f64)

StringLiteral(String)

CallNative(Box<CallNode>)

IfTrue(BinaryExpression)

Children = [condition, then]

IfFalse(BinaryExpression)

Children = [condition, else]

IfElse(Box<[Card; 3]>)

Children = [condition, then, else]

Call(Box<StaticJump>)

Function name

Function(String)

Function name

Creates a pointer to the given cao-lang function

NativeFunction(String)

Function name

Creates a pointer to the given native function

SetGlobalVar(Box<SetVar>)

SetVar(Box<SetVar>)

ReadVar(VarName)

Repeat(Box<Repeat>)

repeats the body N times

While(Box<[Card; 2]>)

Children = [condition, body]

ForEach(Box<ForEach>)

CompositeCard(Box<CompositeCard>)

Single card that decomposes into multiple cards

DynamicCall(Box<DynamicJump>)

Jump to the function that’s on the top of the stack

Get(BinaryExpression)

Get the given integer row of a table [Table, Index]

AppendTable(BinaryExpression)

[Value, Table]

PopTable(UnaryExpression)

Array(Vec<Card>)

Create a Table from the results of the provided cards

Closure(Box<Function>)

Comment(String)

Implementations

impl Card

pub fn name(&self) -> &str

pub fn as_composite_card(&self) -> Option<&CompositeCard>

pub fn as_composite_card_mut(&mut self) -> Option<&mut CompositeCard>

pub fn composite_card(ty: impl Into<String>, cards: Vec<Card>) -> Self

pub fn repeat(n: Card, i: Option<String>, body: Card) -> Self

pub fn set_var(s: impl Into<String>, value: Card) -> Self

pub fn call_native( s: impl Into<InputString>, args: impl Into<Arguments>, ) -> Self

pub fn read_var(s: impl Into<String>) -> Self

pub fn set_global_var(s: impl Into<String>, value: Card) -> Self

pub fn scalar_int(i: i64) -> Self

pub fn string_card(s: impl Into<String>) -> Self

pub fn call_function(s: impl Into<String>, args: impl Into<Arguments>) -> Self

pub fn function_value(s: impl Into<String>) -> Self

pub fn num_children(&self) -> u32

pub fn iter_children_mut<'a>( &'a mut self, ) -> Box<dyn Iterator<Item = &'a mut Card> + 'a>

pub fn iter_children<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Card> + 'a>

pub fn get_child_mut(&mut self, i: usize) -> Option<&mut Card>

pub fn get_child(&self, i: usize) -> Option<&Card>

pub fn remove_child(&mut self, i: usize) -> Option<Card>

pub fn insert_child(&mut self, i: usize, card: Self) -> Result<(), Self>

insert a child at the specified index, if the Card is a list, or replace the child at the index if not

returns the inserted card on failure

pub fn replace_child(&mut self, i: usize, card: Self) -> Result<Self, Self>

Return Ok(old card) on success, return the input card in fail

pub fn return_card(c: Self) -> Self

pub fn set_property(value: Self, table: Self, key: Self) -> Self

pub fn get_property(table: Self, key: Self) -> Self

pub fn dynamic_call(function: Card, args: impl Into<Arguments>) -> Self

Trait Implementations

impl Clone for Card

fn clone(&self) -> Card

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Card

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

Formats the value using the given formatter.

impl Default for Card

fn default() -> Card

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Card

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CompositeCard> for Card

fn from(value: CompositeCard) -> Self

Converts to this type from the input type.

impl From<ForEach> for Card

fn from(value: ForEach) -> Self

Converts to this type from the input type.

impl Serialize for Card

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.