Block Scopes

Curly braces {} and parentheses () and are used to create block scopes in Easel. A block scope can be used to execute multiple statements in sequence. Any variables declared inside a block scope will be deallocated when the block ends. In general, use parentheses for expressions that return values, and curly braces for statements that do not return values.

Curly Braces {}

Use curly braces to create a new scope. When the scope ends, all variables inside of it will be deallocated and will no longer be accessible.

pub game fn World.Main() {
    let a = 2, b = 3
    {
        let c = a + b
        DoSomethingWith(c)
    }
    // Variable `c` is not accessible here
}

Parentheses ()

Use parentheses to determine the order of operations when performing a calculation:

let x = 1 + 2 * 3
let y = (1 + 2) * 3
// x is 7, y is 9

Multiple Statements

To execute multiple statements in parentheses, simply put each statement on a separate line. The last expression in the block determines the resulting value of the parentheses.

let x = (
    let a = 1
    let b = 2
    Print { "Hello, world!" }
    a + b
)
// x is now 3

You can use semicolons to separate statements on the same line. This is the same example as above, but with semicolons instead of newlines:

let x = (let a = 1; let b = 2; Print { "Hello, world!" }; a + b)

Parentheses define a new scope, so after the parentheses end, all variables declared inside of it will be deallocated and will no longer be accessible:

let x = (
    let a = 1
    a + 123
)
let y = a + 456 // Error: unknown identifier `a`

Returning Multiple Values

Use commas to return multiple values from a parentheses block:

let x, y = (1, 2 + 3)
// x is 1, y is 5

You can have multiple statements before the final expression when returning multiple values as well:

let x, y = (
    let a = 1
    let b = 2 + 3
    a, b
)
// x is 1, y is 5

When to Use Parentheses or Curly Braces

tip

When you want to return a value, use parentheses. When you do not want to return a value, use curly braces.

Curly braces and parentheses are the same except for one subtle difference, but you will never need to worry about it if you follow the tip above. It is only noted here for completeness.

Braces and parentheses interpret a nested set of curly braces {} differently:

• When inside a set of parentheses (), a set of curly braces {} will be interpreted as a Map literal.
• When inside a set of curly braces {}, a set of curly braces {} will be interpreted as another block scope.

This difference arises because parentheses are for expressions, and curly braces are for statements.

pub game fn World.Main() {
    let a = 2, b = 3
    
    // Use parentheses to create a block scope inside an expression
    let output = (
        let c = a + b
        DoSomethingWith(c)
        c // The last expression determines the resulting value
    )
    
    // Braces in an expression create a Map, which is why you have to use parentheses instead of braces
    let x = {
        apple = 123,
        banana = 456,
    }
    
    // This is a block scope - no return value
    {
        let c = a + b
        DoSomethingWith(c)
    }
}