Nitpick Function Specification

Declaration Syntax

All function declarations require a trailing semicolon.

// Canonical form
func:nameOfFunc = ReturnType(ArgType:argName) {
    // Body
};

// Legacy/Alternative form (not valid inside extern blocks)
func nameOfFunc(argName: ArgType) -> ReturnType {
    // Body
}

Return Semantics

• Implicit Result Wrapping: All standard user-defined functions implicitly return Result<ReturnType>. You can return a Result object directly, or use the pass(val) / fail(err) sugar functions.
• Exceptions: main, failsafe, and functions declared inside extern blocks DO NOT return Result<T>. They return their raw types directly.
• Calling Functions: Because standard functions return Result<T>, callers must handle it. Use raw fn() to safely unwrap or drop fn() to discard the result.

Examples: pass/fail/return usage

func:thisFails = uint8(int32:arg) {
    tbb8:err = 1;
    // stuff happens
    fail(err); // sugar for: return Result{error:err, value:NIL, is_error:true};
};

func:thisPasses = uint8(int32:arg) {
    uint8:retVal = 33;
    // stuff happens
    pass(retVal); // sugar for: return Result{error:NIL, value:retVal, is_error:false};
};

func:longForm = flt32() {
    flt32:retVal = 1.2f32;
    // do stuff
    return Result{error:NIL, value:retVal, is_error:false};
};

main and failsafe — Both MANDATORY endpoints

Examples: exit() usage

func:main = int32(int32:argc, int8[]->:argv) {
    // pass()/fail() are INVALID in main
    // exit() call required; normal control flow semantics apply otherwise
    exit(0i32);
};

func:main = int32() {
    // zero-argument form also valid
    exit(0i32);
};

func:failsafe = int32(tbb32:err) {
    // Handle graceful shutdown
    // pass()/fail() are INVALID in failsafe
    // exit() call required; err code must be > 0
    exit(1i32);
};

Note: int8[]-> is Nitpick’s equivalent to C’s char** for argv compatibility.

Exit Code Conventions

• Traditional conventions apply: 0 = no error, > 0 = error

FAILSAFE ERROR CODES (for err in failsafe(tbb32:err))

The failsafe parameter is tbb32, giving range [-2147483647, +2147483647] with ERR sentinel.

Special Values

System Error Codes (negative range: -1 to -2147483647)

Reserved for runtime, OS, and hardware-level errors. These are set by the Nitpick runtime or OS signal handlers — user code should not emit these.

User Error Codes (positive range: 1 to 2147483647)

For application-level errors triggered by !!! code (failsafe invocation).

Usage Notes

• System codes are negative, user codes are positive — easy to distinguish in handlers
• Runtime sets system codes automatically on signals; user code calls !!! code with positive values
• ERR (tbb sentinel) means “we don’t know what happened” — always handle it
• Code 0 should never reach failsafe in normal operation, but handle it gracefully
• Libraries should document their error codes in the 100+ range and avoid collisions