Enum RStmt 

pub enum RStmt {
    Assign(RAssignOp, String, RExpr),
    AssignLhs(RAssignOp, RExpr, RExpr),
    ForLoop {
        var: String,
        seq: RExpr,
        body: Vec<RStmt>,
    },
    WhileLoop {
        cond: RExpr,
        body: Vec<RStmt>,
    },
    Repeat(Vec<RStmt>),
    IfElse {
        cond: RExpr,
        then_body: Vec<RStmt>,
        else_if_branches: Vec<(RExpr, Vec<RStmt>)>,
        else_body: Option<Vec<RStmt>>,
    },
    Return(Option<RExpr>),
    Next,
    Break,
    FunctionDef(RFunction),
    Library {
        pkg: String,
        use_require: bool,
    },
    Source(String),
    Expr(RExpr),
    Comment(String),
    Stopifnot(Vec<RExpr>),
    TryCatch {
        body: Vec<RStmt>,
        handlers: Vec<(String, RFormal, Vec<RStmt>)>,
        finally: Option<Vec<RStmt>>,
    },
    SetMethod {
        generic: String,
        signature: Vec<String>,
        fun: RFunction,
    },
    SetClass {
        class: String,
        contains: Option<String>,
        slots: Vec<(String, RType)>,
    },
}

R statement.

Variants

Assign(RAssignOp, String, RExpr)

Assignment: x <- expr or x <<- expr or x = expr

AssignLhs(RAssignOp, RExpr, RExpr)

Complex left-hand side assignment: x$field <- expr

ForLoop

for (var in seq) { body }

Fields

var: String

seq: RExpr

body: Vec<RStmt>

WhileLoop

while (cond) { body }

Fields

cond: RExpr

body: Vec<RStmt>

Repeat(Vec<RStmt>)

repeat { body }

IfElse

if (cond) { then } else if ... else { else }

Fields

cond: RExpr

then_body: Vec<RStmt>

else_if_branches: Vec<(RExpr, Vec<RStmt>)>

else_body: Option<Vec<RStmt>>

Return(Option<RExpr>)

return(expr)

Next

next (continue)

Break

break

FunctionDef(RFunction)

Function definition: name <- function(formals) { body }

Library

library(pkg) or require(pkg)

Fields

pkg: String

use_require: bool

Source(String)

source("file.R")

Expr(RExpr)

Expression statement

Comment(String)

Comment: # text

Stopifnot(Vec<RExpr>)

stopifnot(...) assertion

TryCatch

tryCatch({ body }, error = function(e) { handler })

Fields

body: Vec<RStmt>

handlers: Vec<(String, RFormal, Vec<RStmt>)>

finally: Option<Vec<RStmt>>

SetMethod

S4 method definition: setMethod(generic, signature, function)

Fields

generic: String

signature: Vec<String>

fun: RFunction

SetClass

S4 class definition

Fields

class: String

contains: Option<String>

slots: Vec<(String, RType)>

Trait Implementations

impl Clone for RStmt

fn clone(&self) -> RStmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RStmt

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

Formats the value using the given formatter.

impl PartialEq for RStmt

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