Introducing Functions in Luma: Expression Power, Clarity, and Higher-Order Elegance

Over the past development cycle, Luma has received one of its most important and powerful upgrades so far: full function support.

That includes:

• Named functions with parameters & return types
• Expression-bodied functions (=>)
• Proper return statements
• Recursive functions
• First-class function types ((int) -> int)
• Passing functions as arguments
• Returning functions from functions
• Lambdas that adapt to the expected function type
• Real Go func codegen under the hood

With these additions, Luma now supports functional patterns, reusable building blocks, clean abstractions, and all the core mechanisms needed for expressive programming.

This is a major milestone for the language.

Clear and Explicit Function Definitions

Luma functions emphasize clarity:

fn add(a: int, b: int) -> int {
    return a + b
}

Every function clearly shows:

• What parameters it expects,
• What type it returns,
• And that the function body ends with an explicit return.

Expression-Bodied Functions (=>)

For simple cases, Luma now supports a concise expression body:

fn add(a: int, b: int) -> int => a + b

This is ideal for short computational helpers, formatting functions, and other one-liner logic.

Recursion Made Simple

Thanks to the improved parser and compiler, recursion “just works”:

fn fact(n: int) -> int {
    if n <= 1 {
        return 1
    }
    return n * fact(n - 1)
}

Recursive functions give students a clear tool to learn fundamental algorithmic thinking.

Higher-Order Functions with Function Types

This release introduces full function types, enabling higher-order functions:

fn apply_twice(f: (int) -> int, x: int) -> int {
    return f(f(x))
}

And because lambdas now respect expected type hints, this works perfectly:

result: int = apply_twice(x -> x + 1, 5)

Under the hood, the compiler generates:

apply_twice(func(x int) int { return x + 1 }, 5)

Luma’s lambda system grew smarter: it inspects the expected type (int) -> int and compiles a fully typed Go closure accordingly.

Returning Functions

Higher-order patterns like function factories now work too:

fn make_adder(a: int) -> (int) -> int {
    return b -> a + b
}

add5: (int) -> int = make_adder(5)
print(add5(10))  // 15

This capability opens the door to functional composition, configuration helpers, and elegant abstractions.

Why This Matters

Functions are the backbone of programming. With this update, Luma becomes significantly more expressive and suitable for:

• Students learning programming fundamentals
• Functional programming beginners
• Teaching recursion, abstraction, and composition
• Writing cleaner, modular, reusable code

And thanks to straightforward syntax, Luma remains easy to read, easy to teach, and easy to reason about.

Behind the Scenes: A Huge Engineering Step

Adding these features required deep work across:

• Lexer
• Parser
• AST extensions
• Type handling
• Code generation
• Go type mapping
• Lambda inference improvements
• Enhanced tests for correctness

The engine now understands rich type structures, produces correctly typed Go closures, and supports function scoping and parameter type propagation.

This brings Luma much closer to its long-term vision.

What’s Next?

Upcoming targets include:

• Closures with captured variables
• Expanded standard library functions
• Better static analysis / error messages
• Pattern matching (long-term goal)
• Playground enhancements

But with functions now in place, Luma’s foundation is strong and ready.