Functions in M7 Script

Overview

Functions in M7 Script enable code modularity and reusability. The language supports named functions, anonymous functions, variadic parameters, type annotations (optional), strong type hinting, named arguments, and lexical closures.

---

1. Named Functions

Named functions are declared using the function keyword.

function add(a, b): int {
    return a + b;
}

• Function parameters do not require explicit type declarations, but they can be specified.
• Return types can be explicitly declared.

---

2. Anonymous Functions (Lambdas)

Anonymous functions can be assigned to variables or passed as arguments.

callable adder = function(x, y): int {
    return x + y;
};

print(adder(3, 4)); // Outputs 7

---

3. Named and Default Arguments

M7 supports key-value named arguments, which must follow positional parameters.

function greet(name: "User", greeting: string = "Hello") {
    print(greeting . ", " . name . "!");
}

greet(); // Outputs: Hello, User!
greet("Alice"); // Outputs: Hello, Alice!
greet("Alice", greeting: "Hi"); // Outputs: Hi, Alice!

• Named arguments can be used in function declarations and calls.
• Default values can be assigned using =.

---

4. Variadic Functions

A function can accept a variable number of arguments using the ... operator.

function sum(a, ...numbers): int {
    var total = a;
    foreach (numbers as value) {
        total += value;
    }
    return total;
}

print(sum(1, 2, 3, 4, 5)); // Outputs 15

• Variadic functions cannot be mixed with named arguments.

---

5. Type Annotations and Strong Type Hinting

M7 allows explicit type declarations for function parameters and return values, but they are optional.

function isPositive(n): bool {
    return n > 0;
}

• Type mismatches result in runtime errors if type annotations are used.
• The callable type is used for function references.

---

6. Function References and Higher-Order Functions

Functions are first-class citizens and can be passed as arguments.

function apply(callable fn, x, y): int {
    return fn(x, y);
}

print(apply(adder, 2, 3)); // Outputs 5

---

7. Scope and References

• Scalars (int, float, bool, string) are passed by value.
• Complex types (array, hash, callable) are passed by reference.

function modifyArray(array values) {
    values[0] = 99;
}

var myArray = [1, 2, 3];
modifyArray(myArray);
print(myArray[0]); // Outputs: 99

function callFunction(callable fn) {
    return fn();
}

function sayHello(): string {
    return "Hello";
}

print(callFunction(sayHello)); // Outputs: Hello

---

8. Lexical Environments and Closures

M7 supports lexical closures, meaning functions can capture and retain access to variables from their defining scope.

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

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

• Closures retain access to their parent scope even after the outer function has exited.
• Useful for stateful function behavior.

---

9. Planned Feature: %<variableName> for Capturing Named Arguments

M7 will introduce %<variableName>, which will capture all name/value arguments that are not explicitly assigned to function parameters.

function logMessage(string message, %extraData) {
    print("Message: " . message);
    print("Additional Data: " . extraData);
}

logMessage("Hello", level: "info", user: "Alice");

• %<variableName> will store unassigned named arguments as a hash.
• Ensures flexibility in function calls while maintaining structured parameter handling.

---

This document provides an overview of functions in M7 Script, including function declarations, types, references, closures, and scope handling.