Scopes & Blocks in M7 Script

Overview

M7 Script follows lexical scoping, meaning that variable scope is determined by the location of variable declarations in the source code. It also supports block closures and constant declarations to provide structured and predictable execution.

---

1. Lexical Scoping

• Variables are scoped based on where they are defined, not where they are called.
• Inner functions and blocks inherit variables from outer scopes.

var globalVar = 10;

function testScope() {
    var localVar = 5;
    print(globalVar); // Accessible
    print(localVar);  // Accessible
}

testScope();
print(localVar); // ERROR: localVar is not defined outside testScope

Nested Scope Example

function outer() {
    var outerVar = "Outer";
    
    function inner() {
        print(outerVar); // Inherits from outer scope
    }
    
    return inner;
}

var fn = outer();
fn(); // Outputs: Outer

---

2. Blocks and Block Scoping

• Blocks are enclosed in {} and define their own scope.
• Variables declared inside a block are not accessible outside the block.

if (true) {
    var insideBlock = "Scoped";
    print(insideBlock); // OK
}

print(insideBlock); // ERROR: insideBlock is not accessible here

Standalone Block Closures

• Blocks can be used without a control statement to create a new scope.
• This is useful for temporary variables or scoping side effects.

{
    var temp = "Temporary value";
    print(temp); // OK
}

print(temp); // ERROR: temp is not accessible outside the block

---

3. Constant Declarations

• const declares immutable variables that cannot be reassigned after initialization.
• Constants are block-scoped just like normal variables.

const MAX_SIZE = 100;
MAX_SIZE = 200; // ERROR: Cannot reassign a constant

• Example of Block-Scoped Constants

if (true) {
    const blockConst = "I exist only here";
    print(blockConst);
}
print(blockConst); // ERROR: blockConst is not accessible outside the block

---

4. Closures and Capturing Variables

• Functions can capture variables from their defining scope, creating closures.
• These retained variables persist even after the function execution completes.

function counter(): callable {
    var count = 0;
    return function(): int {
        count += 1;
        return count;
    };
}

var countFn = counter();
print(countFn()); // Outputs: 1
print(countFn()); // Outputs: 2

---

5. Control Statements and Scope

• Control statements (if, for, while, etc.) follow regular block scoping rules.
• If a variable is declared in the condition segment of a statement, it remains accessible inside all branches of the statement.

if (var x = foo()) {
    print(x); // Accessible inside the `if` block
} else {
    print(x); // Also accessible inside the `else` block
}

• Each block in a control statement is its own closure.

Loop Variable Scope

• Variables declared in a loop condition exist inside the loop body.

for (var i = 0; i < 10; i++) {
    print(i); // i is accessible inside the loop
}

print(i); // ERROR: i is not accessible outside the loop

while (var running = checkStatus()) {
    print("Running: " . running);
}

print(running); // ERROR: running is scoped to the while loop

---

This document provides an overview of scopes and blocks in M7 Script, including lexical scoping, block closures, constants, and control statement scoping.