# Functions ```cplus fn add(x: i32, y: i32) -> i32 { return x +% y; } // No return type means the unit type (). fn shout(msg: str) { #println(msg); } // Functions are public by default; a leading `_` makes one file-private. fn answer() -> i32 { return 42; } ``` Every function body **must** end with `return EXPR;`. There is no implicit tail return at the function level (the rule is **E0333**). Block expressions can still be tail expressions inside a `return` or a `let`: ```cplus fn classify(n: i32) -> i32 { return if n < 0 { -1 } else if n == 0 { 0 } else { 1 }; } ``` Generics use square brackets, not angle brackets (see [Ownership](/docs/ownership) for how arguments are passed): ```cplus fn identity[T](x: T) -> T { return x; } fn max[T: Ord](a: T, b: T) -> T { ... } ``` There is **no function overloading**. A name has one signature, period. That is what lets a reader, or a model, resolve a call to exactly one definition. ## Named arguments and default parameters A parameter may declare a **default value**, used when the caller omits the argument: ```cplus fn drop_first(this, count: usize = 1) -> Text { ... } let a = s.drop_first(); // count defaults to 1 let b = s.drop_first(3); // count = 3 ``` An argument may also be passed **by name**, which documents intent at the call site and pairs naturally with defaulted parameters: ```cplus let name = root.value(for_key: "name"); ``` Named arguments resolve through a type alias: `type Color = vocab::Color; Color::adaptive(light: a, dark: b)` finds `vocab::Color`'s signature. ## Function contracts A function or method may declare machine-checked preconditions and postconditions. Each is a pure `bool` expression; the compiler emits it through the same `assert` path used elsewhere (a violation traps; a test build reports instead of aborting). v0.0.27 checks contracts in every build profile. ```cplus #[requires(n > 0)] fn reciprocal(n: i32) -> i32 { return 1 / n; } #[ensures(result >= n)] fn bump(n: i32) -> i32 { return n +% 1; } ``` Rules, all compiler-enforced: - The expression must be `bool` and **pure** (no calls, no assignments). Anything else is **E0924**. - `#[requires]` is checked at entry, over parameters, `this` fields, and consts. It is repeatable. - `#[ensures]` is checked at **every** `return`, after the value exists and before scope-exit drops. `result` names the returned value. - A postcondition on a function that returns nothing is allowed (it can speak about `this` and `ref` parameters) but naming `result` there is **E0928**, as is a parameter that collides with that binding. - A contract sits between the call and the `ret`, so a contracted function is never a tail call. `old()` state capture is not in this release. ## Functions whose safety rests on a caller-side invariant There is **no `unsafe` keyword** and **no `unsafe { }` block**. A function whose contract the compiler cannot verify is just an ordinary `fn`: it carries no extra marker, and its call site stays bare. ```cplus fn as_str(this) -> str { ... } // caller must uphold the invariant let view: str = t.as_str(); ``` What makes such an operation visible is the operation itself, not a wrapper: a raw deref or index is `*p` / `p[i]`, making a pointer is `x as *T`, a pointer-to-int is the loud `#addr(p)` intrinsic, and a foreign call cannot appear without a preceding `extern fn` declaration. The declaration is the marker; the call stays bare. So a method like `Text::as_str` or a raw FFI return reads as plain C+ — the invariant lives in the function's documentation, not in syntax.