Section 15B: Function Syntax

Goal: Implement function-related syntax proposals

Source: docs/ori_lang/proposals/approved/

15B.1 Remove Dot Prefix from Named Arguments

Proposal: proposals/approved/remove-dot-prefix-proposal.md

Change named argument syntax from .name: value to name: value. All functions require named arguments — no exceptions.

// Before
fetch_user(.id: 1)
print("Hello")  // positional was allowed for built-ins

// After
fetch_user(id: 1)
print(msg: "Hello")  // named required everywhere

Key Design Decisions

All functions require named arguments (built-ins, user-defined, methods)
Only function variable calls allow positional: let f = x -> x + 1; f(5)
Type conversions use as syntax (see 15D), not function calls
No positional shorthand (foo(x) meaning foo(x: x) is NOT supported — but see 15B.5 for foo(x:) punning with trailing colon)

Implementation

Parser (dot removal done, enforcement needed)

Built-in Function Updates

Formatter

Implement: Width-based stacking rule (inline if fits, stack if not)
- Rust Tests: ori_formatter/src/ — width-based stacking
- Ori Tests: formatter integration tests

Migration Tool

Implement: ori migrate remove-dot-prefix command
- Finds .identifier: patterns and removes the dot
- --dry-run flag for preview

Documentation & Tests

Implement: Update all existing tests to use named arguments for built-ins
Implement: Update spec examples to use named arguments everywhere
Implement: Update CLAUDE.md examples (partially done)

15B.2 Default Parameter Values

Proposal: proposals/approved/default-parameters-proposal.md

Allow function parameters to specify default values, enabling callers to omit arguments.

@greet (name: str = "World") -> str = `Hello, {name}!`

greet()               // "Hello, World!"
greet(name: "Alice")  // "Hello, Alice!"

Parser

Type Checker

Call Site Validation

Code Generation

Trait Method Defaults

15B.3 Multiple Function Clauses

Proposal: proposals/approved/function-clauses-proposal.md

Allow functions to be defined with multiple clauses that pattern match on arguments.

@factorial (0: int) -> int = 1
@factorial (n) -> int = n * factorial(n - 1)

@abs (n: int) -> int if n < 0 = -n
@abs (n) -> int = n

Parser

Semantic Analysis

Exhaustiveness & Reachability

Code Generation

Integration

15B.4 Positional Lambdas for Single-Parameter Functions

Proposal: proposals/approved/single-lambda-positional-proposal.md

Allow omitting parameter names when calling single-parameter functions with inline lambda expressions.

// Before (required)
items.map(transform: x -> x * 2)
items.filter(predicate: x -> x > 0)

// After (allowed)
items.map(x -> x * 2)
items.filter(x -> x > 0)

The Rule

When ALL of the following are true:

Function has exactly one explicit parameter (excluding self for methods)
The argument expression is a lambda literal

THEN: The parameter name may be omitted.

What Counts as a Lambda?

Lambda expressions (allowed positional):

x -> expr (single parameter)
(a, b) -> expr (multiple parameters)
() -> expr (no parameters)
(x: int) -> int = expr (typed lambda)

NOT lambda expressions (named arg required):

Variables holding functions: let f = x -> x + 1; list.map(f)
Function references: list.map(double)

Type Checker

Error Messages

Implement: Clear error when using positional non-lambda for single-param function
- Rust Tests: ori_diagnostic/src/problem.rs — positional non-lambda error
- Ori Tests: tests/compile-fail/positional_non_lambda_message.ori

error[E2011]: named arguments required for direct function calls
  --> src/main.ori:5:12
   |
5  |     items.map(double)
   |               ^^^^^^
   |
   = help: use named argument syntax: `map(transform: double)`
   = note: positional arguments are only allowed for inline lambda
           expressions, not function references

Edge Cases

Documentation

Implement: Update spec 09-expressions.md with lambda positional exception
Implement: Update CLAUDE.md with lambda positional syntax

15B.5 Argument Punning (Call Arguments)

Proposal: proposals/approved/argument-punning-proposal.md

Allow omitting the value in a named function argument when the argument name matches the variable name: f(x:) for f(x: x). Parser-only desugaring — type checker, evaluator, and LLVM see the expanded form.

// Before:
conv2d(input: input, weight: weight, bias: bias, stride: 2)

// After:
conv2d(input:, weight:, bias:, stride: 2)

Parser

Implement: In call argument parsing, when name: followed by , or ), create synthetic Expr::Ident
- Rust Tests: ori_parse/src/grammar/expr/postfix/tests.rs — punned call arg parsing
- Ori Tests: tests/spec/expressions/argument_punning.ori
Implement: Mixed punned and explicit arguments parse correctly
- Ori Tests: tests/spec/expressions/argument_punning_mixed.ori
Implement: f(x) positional unchanged (no regression)
- Ori Tests: tests/spec/expressions/positional_arg_regression.ori

Error Messages

Implement: f(x:) when x not in scope produces “cannot find value x”
- Ori Tests: tests/compile-fail/punning_not_in_scope.ori
Implement: f(x:) when function has no param x produces existing “unknown parameter” error
- Ori Tests: tests/compile-fail/punning_unknown_param.ori

Formatter

Implement: Detect name == value_ident in call args and emit name: form
- Rust Tests: ori_fmt/src/formatter/ — call arg punning canonicalization
Implement: Preserve f(x: other) — no punning when names differ
- Rust Tests: ori_fmt/src/formatter/ — non-punning preservation

Documentation

Implement: Update spec 09-expressions.md with call argument punning
Implement: Update grammar.ebnf with optional expression in named_arg
Implement: Update .claude/rules/ori-syntax.md with punning syntax

15B.6 Section Completion Checklist

All implementation items have checkboxes marked [ ]
All spec docs updated
CLAUDE.md updated with syntax changes
Migration tools working
All tests pass: ./test-all.sh

Exit Criteria: Function syntax proposals implemented