M7 Script

Support for Functional Constructs in M7 Script

When we say that M7 Script supports functional constructs, it means that while it is primarily a procedural language, it incorporates features commonly associated with functional programming. These features provide flexibility in how code is structured and executed.

1. First-Class Functions

• Functions in M7 Script are first-class citizens, meaning they can be:
  • Assigned to variables
  • Passed as arguments to other functions
  • Returned from functions
• Example:

  function double(n) { return n * 2; }
  let fn = double;
  print(fn(5)); // 10
  

2. Anonymous (Lambda) Functions

• M7 Script allows defining functions without names for inline execution.
• Useful for callbacks and short-lived operations.
• Example:

  let adder = function(x, y) { return x + y; };
  print(adder(3, 4)); // 7
  

3. Higher-Order Functions

• Functions that take other functions as arguments or return functions.
• This enables functional composition and callback-based logic.
• Example:

  function applyTwice(func, value) {
      return func(func(value));
  }
  
  print(applyTwice(double, 2)); // 8
  

4. Closures

• Functions can capture and retain access to variables from their outer scope, even after that scope has exited.
• Example:

  function makeCounter() {
      let count = 0;
      return function() {
          count += 1;
          return count;
      };
  }
  
  let counter = makeCounter();
  print(counter()); // 1
  print(counter()); // 2
  

5. Variadic Functions

• M7 Script supports variable-length arguments using the spread operator (...).
• Example:

  function sum(...numbers) {
      let total = 0;
      for (num in numbers) {
          total += num;
      }
      return total;
  }
  
  print(sum(1, 2, 3, 4, 5)); // 15
  

6. Immutable and Typed Variables

• M7 Script supports strictly-typed variables where a declared type cannot change.
• Example:

  int a = 5;  // 'a' must always contain an integer.
  a = "hello"; // ERROR: Type mismatch
  

• Constants can be declared using const, ensuring the value does not change but allowing any data type:

  const a = 5; // A constant value, cannot be reassigned.
  

• For a full list of variable declaration types, refer to (link to declaration types section).

How Functional Constructs Enhance M7 Script

• Enable cleaner, more expressive code.
• Allow higher-level abstractions, making data transformation and manipulation easier.
• Improve code reuse through higher-order functions and closures.
• Facilitate modular design, especially in large-scale scripting tasks.

Note: While M7 Script does not yet support Object-Oriented Programming (OOP), it can be simulated using functional constructs.

Example of OOP Simulation with Functional Constructs:

function createDog(name, breed) {
    return {
        name: name,
        breed: breed,
        speak: function() {
            return "Woof! My name is " . this.name;
        }
    };
}

dog = createDog("Buddy", "Labrador");
print(dog.speak()); // Woof! My name is Buddy

---

This document provides an overview of functional programming support in M7 Script and how it enhances code flexibility and expressiveness.