Strengthening Luma with Logical Foundations

Over the past development sprint, we’ve taken another significant step toward making Luma a practical and reliable language. Our focus was on strengthening the compiler and parser foundations by tackling areas that often cause hidden complexity in language design: logical operators, conditional flow, and type-aware code generation.

Logical Operators Arrive

Until now, Luma expressions could do math and comparisons, but true logical reasoning (&&, ||, !) wasn’t supported. We carefully extended the lexer, parser, and generator so these operators now work cleanly with the existing precedence system. Importantly, we didn’t hack them in - we aligned their precedence with arithmetic and comparison operators to avoid surprising results. This ensures conditions like:

if ready && !error {
    print("All good")
}

compile down to the expected Go semantics.

Smarter Conditionals

We refined if/else support in the compiler, making it handle both simple and nested branches without breaking readability in the generated Go code. This also means else-if chains now compile correctly, keeping Luma expressive but predictable.

Optional Types Meet Logic

One of Luma’s core strengths - optional types - needed to interact gracefully with logical and comparison operators. We updated the compiler to ensure that comparing an optional against a plain value automatically expands into a safe, nil-checked comparison. That means Luma developers can write:

x: ?int = "3".to_int()
if x > 2 {
    print("Greater")
}

without worrying about nil crashes. Under the hood, Luma expands this into a safe Go check.

Type-Safe Maps and Ranges

We fixed how maps and ranges compile, so that Luma’s concise syntax like:

dict: {str: int} = {"age": 25}
(0..=3).walk(i, v) -> print("${i}: ${v}")

now generate idiomatic Go code with proper typing and iteration logic. This closes a gap where earlier attempts produced incorrect Go constructs.

Why This Matters

These updates are not just bug fixes - they represent deep structural improvements. Logical operators, conditionals, optionals, maps, and ranges are the everyday bread and butter of any language. By making them type-safe, predictable, and tightly integrated into the compiler, we’ve ensured Luma’s foundation can handle real-world programs without hidden surprises.

The Value

For developers, the value is clear:

• Clarity: Luma conditions read naturally, with no strange operator precedence surprises.
• Safety: Optional-aware comparisons remove the fear of nil crashes.
• Consistency: Maps, ranges, and walks all compile into uniform, idiomatic Go.
• Future-Proofing: With logical operators and conditionals integrated at the AST and compiler level, extending Luma further (like adding switch or pattern matching) will be straightforward.

With these milestones, Luma isn’t just “working” - it’s becoming trustworthy. Each feature we’ve added or fixed strengthens the guarantee that what you write in Luma will behave as you intuitively expect, while compiling to clean and efficient Go.