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 — Add ParamKind::Variadic(Type) or is_variadic flag on Param in AST
ori_parse — Parse ...T in parameter position, ...expr spread in call position
ori_types — Convert ...T to [T] internally, validate spread type compatibility, enforce “last param only” rule
ori_eval — Collect variadic args into list at call site, expand spread operator
ori_llvm — Codegen for variadic arg collection (stack allocation or heap list), C variadic ABI (va_list) for extern functions

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

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: *byte, ...) -> 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.

Section Completion Checklist

All items above have all checkboxes marked [ ]
Spec updated: spec/10-declarations.md variadic section complete
CLAUDE.md updated with variadic syntax
Homogeneous variadics work
Spread operator works
C variadic interop works (after Section 11)
All tests pass: ./test-all.sh

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

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"