Enum RExpr 

pub enum RExpr {
    Lit(RLiteral),
    Var(String),
    Call(Box<RExpr>, Vec<RArg>),
    InfixOp(String, Box<RExpr>, Box<RExpr>),
    UnaryOp(String, Box<RExpr>),
    IndexSingle(Box<RExpr>, Vec<RExpr>),
    IndexDouble(Box<RExpr>, Box<RExpr>),
    DollarAccess(Box<RExpr>, String),
    AtAccess(Box<RExpr>, String),
    Formula(Option<Box<RExpr>>, Box<RExpr>),
    IfElse(Box<RExpr>, Box<RExpr>, Option<Box<RExpr>>),
    Lambda(Vec<RFormal>, Box<RExpr>),
    Pipe(Box<RExpr>, Box<RExpr>),
    MagrittrPipe(Box<RExpr>, Box<RExpr>),
    Seq(Box<RExpr>, Box<RExpr>),
    CVec(Vec<RExpr>),
    ListExpr(Vec<RArg>),
    Block(Vec<RStmt>),
    Namespace(String, String),
    NamespaceInternal(String, String),
}

R expression.

Variants

Lit(RLiteral)

Literal value

Var(String)

Variable reference: x

Call(Box<RExpr>, Vec<RArg>)

Function call: f(a, b, named = c)

InfixOp(String, Box<RExpr>, Box<RExpr>)

Infix operator: a + b, a & b, a %in% b

UnaryOp(String, Box<RExpr>)

Unary operator: !x, -x, +x

IndexSingle(Box<RExpr>, Vec<RExpr>)

Single-bracket index: x[i]

IndexDouble(Box<RExpr>, Box<RExpr>)

Double-bracket index: x[[i]]

DollarAccess(Box<RExpr>, String)

Dollar-sign access: x$field

AtAccess(Box<RExpr>, String)

At-sign access: x@slot (S4)

Formula(Option<Box<RExpr>>, Box<RExpr>)

Formula: y ~ x + z

IfElse(Box<RExpr>, Box<RExpr>, Option<Box<RExpr>>)

If-else expression: if (cond) a else b

Lambda(Vec<RFormal>, Box<RExpr>)

Anonymous function (lambda): function(x, y) x + y

Pipe(Box<RExpr>, Box<RExpr>)

Native pipe: x |> f()

MagrittrPipe(Box<RExpr>, Box<RExpr>)

Magrittr pipe: x %>% f()

Seq(Box<RExpr>, Box<RExpr>)

Sequence: 1:10

CVec(Vec<RExpr>)

c() vector constructor

ListExpr(Vec<RArg>)

list() constructor

Block(Vec<RStmt>)

Block expression: { stmt; ...; expr }

Namespace(String, String)

Namespace access: pkg::func

NamespaceInternal(String, String)

Double-colon access: pkg:::func (internal)

Trait Implementations

impl Clone for RExpr

fn clone(&self) -> RExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RExpr

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

Formats the value using the given formatter.

impl PartialEq for RExpr

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