Enum Expr 

pub enum Expr {
    Null,
    Na(NaType),
    Inf,
    NaN,
    Bool(bool),
    Integer(i64),
    Double(f64),
    Complex(f64),
    String(String),
    Symbol(String),
    Dots,
    DotDot(u32),
    UnaryOp {
        op: UnaryOp,
        operand: Box<Expr>,
    },
    BinaryOp {
        op: BinaryOp,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Assign {
        op: AssignOp,
        target: Box<Expr>,
        value: Box<Expr>,
    },
    Call {
        func: Box<Expr>,
        args: Vec<Arg>,
        span: Option<Span>,
    },
    Index {
        object: Box<Expr>,
        indices: Vec<Arg>,
    },
    IndexDouble {
        object: Box<Expr>,
        indices: Vec<Arg>,
    },
    Dollar {
        object: Box<Expr>,
        member: String,
    },
    Slot {
        object: Box<Expr>,
        member: String,
    },
    NsGet {
        namespace: Box<Expr>,
        name: String,
    },
    NsGetInt {
        namespace: Box<Expr>,
        name: String,
    },
    Formula {
        lhs: Option<Box<Expr>>,
        rhs: Option<Box<Expr>>,
    },
    If {
        condition: Box<Expr>,
        then_body: Box<Expr>,
        else_body: Option<Box<Expr>>,
    },
    For {
        var: String,
        iter: Box<Expr>,
        body: Box<Expr>,
    },
    While {
        condition: Box<Expr>,
        body: Box<Expr>,
    },
    Repeat {
        body: Box<Expr>,
    },
    Break,
    Next,
    Return(Option<Box<Expr>>),
    Block(Vec<Expr>),
    Function {
        params: Vec<Param>,
        body: Box<Expr>,
    },
    Program(Vec<Expr>),
}

AST node types for the R language

Variants

Null

NULL literal

Na(NaType)

NA (with optional type)

Inf

Inf

NaN

NaN

Bool(bool)

Boolean literal

Integer(i64)

Integer literal

Double(f64)

Double/float literal

Complex(f64)

Complex literal (imaginary part only, e.g. 2i)

String(String)

String literal

Symbol(String)

Identifier/symbol

Dots

… (dots)

DotDot(u32)

..1, ..2, etc.

UnaryOp

Unary operation

Fields

op: UnaryOp

operand: Box<Expr>

BinaryOp

Binary operation

Fields

op: BinaryOp

lhs: Box<Expr>

rhs: Box<Expr>

Assign

Assignment

Fields

op: AssignOp

target: Box<Expr>

value: Box<Expr>

Call

Function call

Fields

func: Box<Expr>

args: Vec<Arg>

span: Option<Span>

Index

Single bracket indexing: x[i]

Fields

object: Box<Expr>

indices: Vec<Arg>

IndexDouble

Double bracket indexing: x[[i]]

Fields

object: Box<Expr>

indices: Vec<Arg>

Dollar

Dollar access: x$name

Fields

object: Box<Expr>

member: String

Slot

Slot access: x@slot

Fields

object: Box<Expr>

member: String

NsGet

Namespace access: pkg::name

Fields

namespace: Box<Expr>

name: String

NsGetInt

Internal namespace access: pkg:::name

Fields

namespace: Box<Expr>

name: String

Formula

Formula: ~ expr or lhs ~ rhs

Fields

lhs: Option<Box<Expr>>

rhs: Option<Box<Expr>>

If

if/else expression

Fields

condition: Box<Expr>

then_body: Box<Expr>

else_body: Option<Box<Expr>>

For

for loop

Fields

var: String

iter: Box<Expr>

body: Box<Expr>

While

while loop

Fields

condition: Box<Expr>

body: Box<Expr>

Repeat

repeat loop

Fields

body: Box<Expr>

Break

break

Next

next (continue)

Return(Option<Box<Expr>>)

return

Block(Vec<Expr>)

Block (curly braces)

Function

Function definition

Fields

params: Vec<Param>

body: Box<Expr>

Program(Vec<Expr>)

Program (sequence of top-level expressions)

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> 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 StructuralPartialEq for Expr