Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

#![allow(unused)]

fn main() {
#[path = "expressions/block-exprs.md.rs"]
pub mod block_expressions;
#[path = "expressions/call-exprs.md.rs"]
pub mod call_expressions;
#[path = "expressions/literal-exprs.md.rs"]
pub mod literal_expressions;
#[path = "expressions/operator-exprs.md.rs"]
pub mod operator_expressions;

pub use block_expressions::*;
pub use call_expressions::*;
pub use literal_expressions::*;
pub use operator_expressions::*;
}

Expressions

This section is a work-in-progress experiment about making the book executable.

Syntax
Expression:
    | expr=ExpressionWithoutBlock => expr
    | expr=ExpressionWithBlock => expr
ExpressionWithoutBlock: attrs=OuterAttribute* kind=ExpressionWithoutBlockNoAttrs
    => Expression { attrs, kind }
ExpressionWithBlock: attrs=OuterAttribute* kind=ExpressionWithBlockNoAttrs
    => Expression { attrs, kind }
ExpressionWithoutBlockNoAttrs:
    | literal=LiteralExpression => ExpressionKind::Literal(literal)
    | path=PathExpression => ExpressionKind::Path(path)
    | operator=OperatorExpression => ExpressionKind::Operator(Box::new(operator))
    | tuple=TupleExpression => ExpressionKind::Tuple(tuple)
    | call=CallExpression => ExpressionKind::Call(call)
ExpressionWithBlockNoAttrs: expr=BlockExpression => ExpressionKind::Block(expr)
PathExpression: variable=Identifier => variable
TupleExpression: ( ) => TupleExpression::Unit

#![allow(unused)]
fn main() {
pub struct Expression {
    pub attrs: Vec<OuterAttribute>,
    pub kind: ExpressionKind,
}

pub enum ExpressionKind {
    Literal(LiteralExpression),
    Path(PathExpression),
    Operator(Box<OperatorExpression>),
    Block(BlockExpression),
    Tuple(TupleExpression),
    Call(CallExpression),
}

pub type PathExpression = Identifier;

pub enum TupleExpression {
    Unit,
}
}