Enum Statement 

pub enum Statement {
    Block(Block),
    LetBinding {
        params: Vec<Located<Parameter>>,
        exprs: Vec<Located<Expression>>,
    },
    LetElse {
        param: Located<Parameter>,
        expr: Located<Expression>,
        else_case: Located<Block>,
    },
    Assign {
        paths: Vec<Located<Path>>,
        exprs: Vec<Located<Expression>>,
    },
    AssignOperation {
        op: AssignOperator,
        path: Located<Path>,
        expr: Located<Expression>,
    },
    Call {
        path: Located<Path>,
        args: Vec<Located<Expression>>,
    },
    SelfCall {
        head: Located<Path>,
        field: Located<String>,
        args: Vec<Located<Expression>>,
    },
    Fn {
        path: Located<Path>,
        params: Vec<Located<Parameter>>,
        var_args: Option<Located<String>>,
        body: Located<Block>,
    },
    LetFn {
        ident: Located<String>,
        params: Vec<Located<Parameter>>,
        var_args: Option<Located<String>>,
        body: Located<Block>,
    },
    If {
        cond: Located<Expression>,
        case: Located<Block>,
        else_case: Option<Located<Block>>,
    },
    IfLet {
        param: Located<Parameter>,
        expr: Located<Expression>,
        case: Located<Block>,
        else_case: Option<Located<Block>>,
    },
    Match {
        expr: Located<Expression>,
        cases: Vec<(Located<Pattern>, Located<Block>)>,
    },
    While {
        cond: Located<Expression>,
        body: Located<Block>,
    },
    WhileLet {
        param: Located<Parameter>,
        expr: Located<Expression>,
        body: Located<Block>,
    },
    For {
        ident: Located<String>,
        iter: Located<Expression>,
        body: Located<Block>,
    },
    Return(Option<Located<Expression>>),
    Break,
    Continue,
}

Variants

Block(Block)

LetBinding

Fields

params: Vec<Located<Parameter>>

exprs: Vec<Located<Expression>>

LetElse

Fields

param: Located<Parameter>

expr: Located<Expression>

else_case: Located<Block>

Assign

Fields

paths: Vec<Located<Path>>

exprs: Vec<Located<Expression>>

AssignOperation

Fields

op: AssignOperator

path: Located<Path>

expr: Located<Expression>

Call

Fields

path: Located<Path>

args: Vec<Located<Expression>>

SelfCall

Fields

head: Located<Path>

field: Located<String>

args: Vec<Located<Expression>>

Fn

Fields

path: Located<Path>

params: Vec<Located<Parameter>>

var_args: Option<Located<String>>

body: Located<Block>

LetFn

Fields

ident: Located<String>

params: Vec<Located<Parameter>>

var_args: Option<Located<String>>

body: Located<Block>

If

Fields

cond: Located<Expression>

case: Located<Block>

else_case: Option<Located<Block>>

IfLet

Fields

param: Located<Parameter>

expr: Located<Expression>

case: Located<Block>

else_case: Option<Located<Block>>

Match

Fields

expr: Located<Expression>

cases: Vec<(Located<Pattern>, Located<Block>)>

While

Fields

cond: Located<Expression>

body: Located<Block>

WhileLet

Fields

param: Located<Parameter>

expr: Located<Expression>

body: Located<Block>

For

Fields

ident: Located<String>

iter: Located<Expression>

body: Located<Block>

Return(Option<Located<Expression>>)

Break

Continue

Implementations

impl Statement

pub fn parse_let( parser: &mut Parser, ) -> Result<Located<Self>, Located<ParseError>>

pub fn parse_fn( parser: &mut Parser, local: bool, ) -> Result<Located<Self>, Located<ParseError>>

pub fn parse_if( parser: &mut Parser, ) -> Result<Located<Self>, Located<ParseError>>

pub fn parse_match( parser: &mut Parser, ) -> Result<Located<Self>, Located<ParseError>>

pub fn parse_while( parser: &mut Parser, ) -> Result<Located<Self>, Located<ParseError>>

pub fn parse_for( parser: &mut Parser, ) -> Result<Located<Self>, Located<ParseError>>

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.

impl Parsable for Statement

fn parse(parser: &mut Parser) -> Result<Located<Self>, Located<ParseError>>

impl PartialEq for Statement

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