Section 12: Variadic Functions

Goal: Enable functions with variable number of arguments

Criticality: Medium — API design flexibility, required for C interop

Dependencies: Section 11 (FFI — C variadic interop in 12.4), Section 3 (Traits — trait bounds on variadics in 12.3)

Proposal: proposals/approved/variadic-functions-proposal.md

Sync Points: Variadic Parameter Type (multi-crate sync required)

Adding variadic parameter support requires updates across these crates:

ori_ir — Param.is_variadic, CallArg.is_spread, ExternItem.is_c_variadic, ListElement::Spread, MapElement::Spread, StructLitField::Spread all defined (COMPLETE, verified 2026-03-29)
ori_parse — Parse ...T in parameter position, ...expr spread in call position, C variadic ... in extern blocks; incremental copier handles is_variadic (COMPLETE, verified 2026-03-29)
ori_types — Convert ...T to [T] internally, validate spread type compatibility, enforce “last param only” rule, reject spread in non-variadic calls (GAP-12-003: is_variadic never read by typeck)
ori_eval — Collect variadic args into list at call site, expand spread operator (GAP-12-004: is_spread on CallArg never handled)
ori_llvm — Codegen for variadic arg collection (stack allocation or heap list), C variadic ABI (va_list) for extern functions (GAP-12-005: no variadic codegen)
ori_canon — Collection spread desugaring exists (ori_canon/src/desugar/spread.rs) but no variadic-specific call-site desugaring
ori_fmt — is_c_variadic handled for extern blocks; is_variadic on regular params NOT handled (GAP-12-001); is_spread in call args NOT handled (GAP-12-002)

Design Decisions

Question	Decision	Rationale
Type safety	Homogeneous only	Type safety over flexibility
Syntax	`...T` parameter	Clear, matches common convention
C variadics	Separate syntax	Different semantics require distinction
Minimum args	Configurable	Allow `printf`-style (min 1) or `sum`-style (min 0)

Reference Implementation

Rust

Rust doesn’t have variadic functions in the language; uses macros instead.

~/projects/reference_repos/lang_repos/rust/library/core/src/fmt/mod.rs    # format! handles variadics via macro

Go

~/projects/reference_repos/lang_repos/golang/src/go/types/signature.go    # Variadic signature handling
~/projects/reference_repos/lang_repos/golang/src/cmd/compile/internal/types2/signature.go

Swift

# Swift has variadic generics (parameter packs: each T, repeat each T)
~/projects/reference_repos/lang_repos/swift/lib/Sema/CSSimplify.cpp       # Pack expansion type checking
~/projects/reference_repos/lang_repos/swift/include/swift/AST/Types.h     # PackExpansionType

12.1 Homogeneous Variadics

Spec section: spec/10-declarations.md § Variadic Parameters

Syntax

// Variadic parameter (receives as list)
@sum (numbers: ...int) -> int = {
    numbers.fold(initial: 0, op: (acc, n) -> acc + n)
}

// Usage
sum(1, 2, 3)        // 6
sum(1)              // 1
sum()               // 0

// With required parameters before
@printf (format: str, args: ...Printable) -> str = ...

printf("Hello")                    // "Hello"
printf("{} + {} = {}", 1, 2, 3)   // "1 + 2 = 3"

// Spread operator to pass list as varargs
let nums = [1, 2, 3]
sum(...nums)        // 6
sum(0, ...nums, 4)  // 10

Grammar

Parameter        = Identifier ':' Type | VariadicParameter ;
VariadicParameter = Identifier ':' '...' Type ;
SpreadExpr       = '...' Expression ;

Type Rules

Variadic parameter must be last
Only one variadic parameter allowed
Parameter type ...T becomes [T] inside function
Spread ...list requires list: [T] where T matches variadic

Implementation

HYGIENE: tests/spec/declarations/functions.ori lines 92-120 contain commented-out variadic test code. These should be converted to #skip tests or removed with a plan item tracking them.

/tpr-review passed — independent review found no critical or major issues (or all findings triaged)
/impl-hygiene-review passed — hygiene review clean. MUST run AFTER /tpr-review is clean.
Subsection close-out (12.1) — MANDATORY before starting the next subsection. Run /improve-tooling retrospectively on THIS subsection’s debugging journey (per .claude/skills/improve-tooling/SKILL.md “Per-Subsection Workflow”): which diagnostics/ scripts you ran, where you added dbg!/tracing calls, where output was hard to interpret, where test failures gave unhelpful messages, where you ran the same command sequence repeatedly. Forward-look: what tool/log/diagnostic would shorten the next regression in this code path by 10 minutes? Implement improvements NOW (zero deferral) and commit each via SEPARATE /commit-push using a valid conventional-commit type (build(diagnostics): ... — surfaced by section-12.1 retrospective — build/test/chore/ci/docs are valid; tools(...) is rejected by the lefthook commit-msg hook). Mandatory even when nothing felt painful. If genuinely no gaps, document briefly: “Retrospective 12.1: no tooling gaps”. Update this subsection’s status in section frontmatter to complete.
/sync-claude section-close doc sync — verify Claude artifacts across all section commits. Map changed crates to rules files, check CLAUDE.md, canon.md. Fix drift NOW.
Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files.

12.2 Minimum Argument Count

Spec section: spec/10-declarations.md § Variadic Constraints

Syntax

// Require at least one argument
@max (first: int, rest: ...int) -> int = {
    rest.fold(initial: first, op: (a, b) -> if a > b then a else b)
}

max(1, 2, 3)   // 3
max(5)         // 5
max()          // Error: max requires at least 1 argument

// Explicit minimum (alternative syntax consideration)
@format (fmt: str, args: ...Printable) -> str = ...
// Minimum 1 (fmt) is implicit from required param

Implementation

12.3 Trait Bounds on Variadics

Spec section: spec/10-declarations.md § Variadic Trait Bounds

Syntax

// Generic variadic with trait bound
@print_all<T: Printable> (items: ...T) -> void = {
    for item in items do print(item.to_str())
}

print_all(1, 2, 3)              // OK: all int
print_all("a", "b", "c")        // OK: all str
print_all(1, "a")               // Error: mixed types

// With explicit heterogeneous (trait object)
@print_any (items: ...Printable) -> void = {
    for item in items do print(item.to_str())
}

print_any(1, "hello", true)     // OK: all Printable

Implementation

12.4 C Variadic Interop

Spec section: spec/26-ffi.md § C Variadics

Syntax

// Declare C variadic function
extern "c" {
    @printf (format: CPtr, ...) -> c_int  // C-style variadic
}

// Call with any types (unsafe, no type checking)
unsafe { printf("Number: %d, String: %s\n".as_c_str(), 42, "hello".as_c_str()) }

Distinction from Ori Variadics

Feature	Ori `...T`	C `...`
Type safety	Homogeneous, checked	Unchecked
Context	Safe code	Unsafe only
Implementation	List	va_list ABI

Implementation

12.5 Variadic in Patterns

Spec section: spec/15-patterns.md § Variadic Patterns

Consideration

// Should variadic work in patterns?
@process_commands (commands: ...(str, int)) -> void = {
    for (name, priority) in commands do
        print(`Command: {name}, Priority: {priority}`)
}

process_commands(("init", 1), ("run", 2), ("cleanup", 3))

Decision

Defer to future consideration. Current section focuses on function parameters only.

/tpr-review passed — independent review found no critical or major issues (or all findings triaged)
/impl-hygiene-review passed — hygiene review clean. MUST run AFTER /tpr-review is clean.
Subsection close-out (12.5) — MANDATORY before starting the next subsection. Run /improve-tooling retrospectively on THIS subsection’s debugging journey (per .claude/skills/improve-tooling/SKILL.md “Per-Subsection Workflow”): which diagnostics/ scripts you ran, where you added dbg!/tracing calls, where output was hard to interpret, where test failures gave unhelpful messages, where you ran the same command sequence repeatedly. Forward-look: what tool/log/diagnostic would shorten the next regression in this code path by 10 minutes? Implement improvements NOW (zero deferral) and commit each via SEPARATE /commit-push using a valid conventional-commit type (build(diagnostics): ... — surfaced by section-12.5 retrospective — build/test/chore/ci/docs are valid; tools(...) is rejected by the lefthook commit-msg hook). Mandatory even when nothing felt painful. If genuinely no gaps, document briefly: “Retrospective 12.5: no tooling gaps”. Update this subsection’s status in section frontmatter to complete.
/sync-claude section-close doc sync — verify Claude artifacts across all section commits. Map changed crates to rules files, check CLAUDE.md, canon.md. Fix drift NOW.
Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files.

Section Completion Checklist

Exit Criteria: Can implement format() and call C’s printf()

Verification Summary (2026-03-29)

Overall completion: ~20% — parse/IR infrastructure exists but no typeck/eval/codegen/tests

Subsection	Plan Status	Actual Status	Test Classification
12.1 Homogeneous Variadics	partial	PARTIAL (parse/IR only)	NEEDS TESTS
12.2 Minimum Argument Count	not-started	NOT STARTED	NEEDS TESTS
12.3 Trait Bounds on Variadics	not-started	NOT STARTED	NEEDS TESTS
12.4 C Variadic Interop	partial	PARTIAL (parse only)	WEAK TESTS (parse-only, 2 tests)
12.5 Variadic in Patterns	deferred	NOT APPLICABLE	NOT APPLICABLE

Gap Registry

Gap ID	Description	Phases	Severity
GAP-12-001	`ori_fmt` does not handle `is_variadic` on function params — round-trip loses variadic	Parse -> Fmt	Major
GAP-12-002	`ori_fmt` does not handle `is_spread` in call args — round-trip loses spread	Parse -> Fmt	Major
GAP-12-003	Type checker never reads `is_variadic` — params parsed but not type-checked as variadic	Parse -> Typeck	Critical
GAP-12-004	Evaluator never handles `is_spread` on `CallArg` — spread parsed but not evaluated	Parse -> Eval	Critical
GAP-12-005	No LLVM codegen for variadic arg collection or spread in calls	Typeck -> Codegen	Critical
GAP-12-006	No unsafe enforcement for C variadic callers	Typeck	Major
GAP-12-007	Spread in non-variadic calls not rejected (spec says it should be an error)	Typeck	Major

Hygiene Issues

HYGIENE VIOLATION: tests/spec/declarations/functions.ori lines 92-120 contain commented-out variadic test code. Should be #skip tests or removed with plan item tracking.

Example: Format Function

// Ori's format function (like Python's format or Rust's format!)
@format (template: str, args: ...Printable) -> str = {
    let mut result = ""
    let mut arg_index = 0
    let mut i = 0

    loop {
        if i >= template.len() then break result

        if template[i] == "{" && i + 1 < template.len() && template[i + 1] == "}" then {
            if arg_index >= args.len() then
                panic("Not enough arguments for format string")
            result = result + args[arg_index].to_str()
            arg_index = arg_index + 1
            i = i + 2
        }
        else {
            result = result + template[i]
            i = i + 1
        }
    }
}

// Usage
let msg = format("{} + {} = {}", 1, 2, 3)  // "1 + 2 = 3"