Struct BlockExpression 

pub struct BlockExpression {
    pub span: Span,
    pub statements: Rc<[Statement]>,
}

Represents a block of code in Mechylang, which is a sequence of statements enclosed in curly braces.

A BlockExpression is used to group multiple statements together and is commonly used to represent the body of functions, control structures (like if, for, etc.), and other constructs that contain a sequence of statements. A block expression can however also be used to group expressions, which is useful for expressions that return a value.

Fields

• token - The token representing the opening curly brace { that starts the block. This token is used for error reporting and debugging purposes.
• statements - A sequence of Statement instances contained within the block. The statements are stored in an Rc<[Statement]>, which is a reference-counted smart pointer to a slice, allowing multiple parts of the code to share the same statements without unnecessary copying.

Notes

The BlockExpression struct is used internally by the parser to represent blocks of code. The statements field is a collection of Statement enums, which can represent different types of statements such as variable declarations, expressions, and control flow commands.

It is crucial for understanding how the parser organizes and processes blocks of code in Mechylang.

Example usages

Block expression as a function body

use mechylang::test_utils::test_parse_ok;
test_parse_ok(r#"
fn add(a, b) {
    return a + b;
}
"#);

Block expression as an expression

use mechylang::test_utils::test_parse_ok;
test_parse_ok(r#"
let result = {
    let x = 5;
    let y = 10;
    x + y;
};
// result is now 15
"#);

Block expression in a for loop

use mechylang::test_utils::test_parse_ok;
test_parse_ok(r#"
for i in 1..5 {
    sum += i;
}
"#);

Fields

span: Span

statements: Rc<[Statement]>

Trait Implementations

impl Clone for BlockExpression

fn clone(&self) -> BlockExpression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockExpression

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

Formats the value using the given formatter.

impl Display for BlockExpression

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

Formats the value using the given formatter.

impl PartialEq for BlockExpression

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BlockExpression