Errors
Karkain distinguishes two kinds of error:
Recoverable conditions are values, not exceptions. A function returns an
Optionor aResult; the caller inspects it withmatchor propagates it with?. These are decided at check time.Unrecoverable conditions abort the program at runtime and report a source location (see Runtime errors below).
Result and Option
Karkain has no null and no exceptions. The two carrier types are part of the language itself — they are not standard-library wrappers, and they are written without type arguments:
func first(xs: int[]) -> Option {
if len(xs) == 0 { return None }
return Some(xs[0])
}
func parse(s: string) -> Result {
if s == "" { return Err("empty") }
return Ok(42)
}
OptionSome(v)for a present value,Nonefor absence. Written bare asOption.ResultOk(v)for success,Err(e)for failure. Written bare asResult.
std.core provides the predicates is_some / is_none / is_ok /
is_err. The constructors themselves are language forms, and both engines
lower them to the same value layout (optVal.tag: 0 = None, 1 =
Some; resVal.tag: 0 = Ok, 1 = Err).
Consuming a value with match
match destructures the payload and binds it to a name that is in scope
inside that arm only:
let r = parse("42")
match r {
Ok(n) => { print(n) },
Err(e) => { print(e) },
}
let o = first([1, 2, 3])
match o {
Some(v) => { print(v) },
None => { print("empty") },
}
Bind the scrutinee to a local first. match parse("42") { ... } — a call
expression directly in scrutinee position — is a pre-existing Go parser
limitation and does not parse there; it works when the value is a variable.
An arm body is a block, a print, or a bare expression. All three forms are
semantically checked, with the arm’s binding in scope, on both engines. The
binding does not escape its arm — referring to it after the match is an
error.
Enum arms are different: they are tag-only and carry no binding. See
Control Flow for match as a control-flow construct, and Enums
for enum patterns.
Exhaustiveness
The Go front end enforces exhaustiveness for Option and Result: a match
must cover both Some and None, or both Ok and Err, otherwise it
reports non-exhaustive match on Result: missing pattern(s): ....
The self-hosted kcc checker does not implement this check, so an incomplete
match passes kcc check. It is not a crash: if no arm matches, the match
evaluates to the matched value itself, because that is what the generated code
initialises the result to before testing any arm. Write exhaustive matches
anyway — an unmatched arm silently yielding the scrutinee is easy to mistake for
a correct result.
Error propagation with ?
? unwraps a Result/Option or returns early. The operand is evaluated
exactly once:
func double_it(s: string) -> Result {
let v = parse(s)?
return Ok(v * 2)
}
If the operand is Err or None it becomes the enclosing function’s return
value immediately; otherwise the Ok/Some payload is unwrapped and the
whole expression evaluates to it. Equivalently, expr? behaves like
match expr { Ok(v) => v, Err(e) => return Err(e) }.
? must appear inside a function that itself returns a Result or an
Option. Using it in main is a compile error on both engines — that
is parity, not a gap.
Runtime errors
Runtime errors report a source location and exit with code 1:
runtime error: division by zero at main.kark:5
runtime error: index out of range at main.kark:12
runtime error: string index out of range at main.kark:18
Checked operations
The following operations are bounds-checked and produce a runtime error on failure:
Division / modulo by zero
Array index out of range
String index out of range
Unchecked operations silently return zero (pre-Phase-100 behaviour).
Stack traces (Phase 101)
When a runtime error occurs the engine prints a stack trace showing
the call chain up to KARKAIN_MAX_FRAMES (128) deep:
runtime error: division by zero at main.kark:3
stack:
inner:2
outer:5
main:9
The stack is recorded by karkain_frame_enter /
karkain_frame_leave calls emitted around every function body.
Cross-engine parity
Both the Go front end and the self-hosted kcc engine produce identical
runtime-error messages and stack traces for the same input, and identical
semantics for Result/Option, match arm bindings and ?
propagation.