Luca Code Language Guide

def const name (str) = "Luca"
def var visits (int) = 1
def var inferred = "hello"      -- type inferred as str
visits (int) = visits + 1       -- update without changing type
def var x (int) = none
x.clear()                       -- mutable var back to none (error on const)
forget var x (int)              -- remove the binding entirely
change x (str) = "hi"           -- change a var's type and value

• def var is mutable, def const is immutable. One binding per name per scope.
• Annotations are optional when inference suffices: def var n = 5 infers int.
• A value must match its declared type (or be none, or anything for uni).
• Comments: -- for one line. Strings use double quotes with {name} interpolation wherever a string value is created.

print(10 / 4)                    -- 2.5 (dec)
print(2.50 * 2.00)               -- 5.00
if name is == to "Luca" then :
    print("Hello, {name}!")
print(true and false)            -- false
print(x is == to none)           -- absence check

• int / dec mix → dec; otherwise integer arithmetic stays int. Integer overflow is an error.
• Ordering allows int/dec mixes and str/str; anything else is an error.
• and/or/not require bool. none can be compared for equality but not used in arithmetic or logic.
• print() takes exactly one argument; combine values with interpolation. It prints none as none.

if visits is > to 1 then :
    print("Welcome back, {name}!")
else if visits is == to 1 then :
    print("Welcome!")
else :
    print("Hello.")

for 3 times repeat :
    print("hi")

for item from names repeat :
    print(item)

while visits is > to 0 then :
    visits (int) = visits - 1
    if visits is == to 0 then :
        stop              -- exits the innermost loop
    skip                  -- skips to the next iteration

• for N times repeat : — N must be a non-negative int.
• while condition repeat : — condition must be bool.
• for item from collection repeat : — iterates list/tuple/set values and dict keys.
• stop / skip outside a loop are errors. return inside a loop exits the current function.

def func greet(name (str) = "Luca") (str):
    return "Hello, {name}!"

print(greet())
print(greet("Alex"))

• Syntax: def func name(params) (optional_return_type): with a : block. Calls: name(args).
• Parameters look like name (type) = default; untyped params accept any value. Missing return annotation allows varying returns; bare return or falling off the end returns none.
• An explicit return type requires every returned value to match. Wrong argument count is an error. No overloading.
• Recursion, nested functions, and closures are supported: closures can read and modify captured var; primitive args are independent values while passed collections stay mutable.
• return outside a function is an error. Deep recursion (limit 64) is an error.

def list names (str) = ["Luca", "Alex"]
def tuple data (uni) = (123, true, "Luca")
def set labels (str) = {"alpha", "stable"}
def dict person = {"Name" = "Luca" (str), "Age" = 16 (int)}

print(names[1])                 -- 1-based: "Luca"
names.add("Sam")
print(names.length)             -- item count
print(names.contains("Luca"))   -- true
change names[1] = "Lucca"
person.add("City", "Oslo")
print(person["Name"])

• Literals: lists [ … ], tuples ( … ) (single-element (x,)), sets { … }, dicts {key = value (type), …} with string keys. uni permits mixed elements.
• Indices are 1-based. Missing index/key warns and yields none; execution continues.
• .add / .remove / .clear are statements; .contains / .length / [i] are expressions. Dicts use .add(k, v), .contains(key = k) / .contains(value = v).
• change l[i] = v preserves the element type. Mutating the collection being iterated is an error.
• .length counts collection items, string chars, or int/dec digits; .length(decimals) gives a decimal’s scale. Equality is content-based and recursive.

import Math
import Utils

print(Math.sqrt(25))
Utils.helper()

• import Name (single identifier, no alias/extension) resolves Name.lucc — program directory first, then working directory. Built-ins (Math, Text, File, System) take precedence over same-named files.
• Each module has its own scope; every top-level definition is exported automatically. Access via the real namespace: Module.member, Module.func(args).
• Initialization runs once on first import; later imports reuse it. Circular imports are errors; init errors propagate and may be captured.

try to :
    File.read("data.txt")
capture error :
    print("Could not read the file.")
finally :
    print("Cleanup")

• try to : runs its block; optional capture error : runs on error and binds error for that block; optional finally : always runs. A bare try to : with neither block just propagates.
• Only runtime errors are capturable. The caught value is a dictionary — read fields with error["code"]. Runtime errors carry code = none plus message/line/column.

Custom errors with raise

def error NotFound :
    code = 404
    message = "missing"

raise NotFound()
raise NotFound(code = 410)

try to :
    raise NotFound()
capture error :
    print(error["code"])      -- 404
    print(error["message"])   -- missing

• def error Name : needs at least code and message fields (body runs once at definition; code = none is allowed).
• raise Name(...) is a statement (never a value); parentheses are required. Overrides must name existing fields with matching types (none accepted); repeats warn and keep the first.
• Caught custom errors add line/column of the raise. System.exit stays uncapturable; finally still runs around it.

def const name (str) = ask "What is your name?"
def const age (int) = ask "How old are you?"
print("Hello, {name}. You are {age}.")

• int/dec parse trimmed numbers; bool accepts exactly true/false; str keeps the raw line. Running out of input is an error.
• All library calls use strict argument types, reject none where a real value is required, and check arity.

Current boundary: everything locked for 1.0 Beta is implemented — all types, I/O, collections, functions, control flow, modules, custom-error raising and inspection, the four library modules, and CLI integration (exit codes, System.args wiring, .lucc enforcement).