Section 15D: Bindings & Types

Goal: Implement binding syntax changes and type system simplifications

Source: docs/ori_lang/proposals/approved/

15D.1 Function-Level Contracts: `pre()` / `post()`

Proposal: proposals/approved/checks-proposal.md (semantics), proposals/approved/block-expression-syntax.md (syntax)

Function-level pre() and post() contract declarations for defensive programming. Contracts go between the return type and =:

@divide (a: int, b: int) -> int
    pre(b != 0)
    post(r -> r * b <= a)
= a div b

// Multiple conditions
@transfer (from: Account, to: Account, amount: int) -> (Account, Account)
    pre(amount > 0 | "amount must be positive")
    pre(from.balance >= amount | "insufficient funds")
    post((f, t) -> f.balance == from.balance - amount)
    post((f, t) -> t.balance == to.balance + amount)
= {
    // ... body ...
}

Key Design Decisions

Function-level placement: Contracts go on the declaration between return type and =
Multiple declarations: Use multiple pre() / post() declarations (not list syntax)
| for messages: Custom messages use condition | "message" syntax
Scope constraints: pre() can only access function parameters and module-level bindings; post() can access the result via lambda parameter
Void return: Compile error if post() used on a function returning void
Check modes deferred: check_mode: (enforce/observe/ignore) deferred to future proposal

Implementation

15D.2 `as` Conversion Syntax

Proposal: proposals/approved/as-conversion-proposal.md

Replace int(), float(), str(), byte() with as/as? keyword syntax backed by As<T> and TryAs<T> traits.

// Before (special-cased positional args)
let x = int("42")
let y = float(value)

// After (consistent keyword syntax)
let x = "42" as? int
let y = value as float

Lexer

Implement: as keyword token (if not already reserved)
- Rust Tests: ori_lexer/src/lib.rs — as keyword tokenization
- Ori Tests: tests/spec/lexical/as_keyword.ori
- LLVM Support: LLVM codegen for as keyword
- LLVM Rust Tests: ori_llvm/tests/as_conversion_tests.rs — as keyword codegen
- AOT Tests: No AOT coverage yet

Parser

Type Checker

Codegen

Implement: Desugar x as T to As<T>.as(self: x)
- LLVM Support: LLVM codegen for as desugaring
- LLVM Rust Tests: ori_llvm/tests/as_conversion_tests.rs — as desugaring codegen
- AOT Tests: No AOT coverage yet
Implement: Desugar x as? T to TryAs<T>.try_as(self: x)
- LLVM Support: LLVM codegen for as? desugaring
- LLVM Rust Tests: ori_llvm/tests/as_conversion_tests.rs — as? desugaring codegen
- AOT Tests: No AOT coverage yet

Migration

Implement: Remove int(), float(), str(), byte() from parser
- LLVM Support: LLVM codegen for type conversion removal
- LLVM Rust Tests: ori_llvm/tests/as_conversion_tests.rs — type conversion removal codegen
- AOT Tests: No AOT coverage yet
Implement: Update error messages to suggest as syntax
- LLVM Support: LLVM codegen for as syntax suggestion
- LLVM Rust Tests: ori_llvm/tests/as_conversion_tests.rs — as syntax suggestion codegen
- AOT Tests: No AOT coverage yet

15D.3 Simplified Bindings with `$` for Immutability

Proposal: proposals/approved/simplified-bindings-proposal.md

Simplify the binding model: let x is mutable, let $x is immutable. Remove mut keyword. Module-level bindings require $ prefix.

// Before
let x = 5         // immutable
let mut x = 5     // mutable
$timeout = 30s    // config variable

// After
let x = 5         // mutable
let $x = 5        // immutable
let $timeout = 30s // module-level constant (let and $ required)

Lexer

Implement: Remove mut from reserved keywords
- Rust Tests: ori_lexer/src/lib.rs — keyword list update
- Ori Tests: tests/spec/lexical/mut_not_keyword.ori
- LLVM Support: LLVM codegen for mut removal
- LLVM Rust Tests: ori_llvm/tests/binding_tests.rs — mut removal codegen
- AOT Tests: No AOT coverage yet

Parser

Semantic Analysis

Imports

Shadowing

Implement: Allow shadowing to change mutability
- Rust Tests: ori_types/src/check/binding.rs — shadowing mutability change
- Ori Tests: tests/spec/expressions/shadow_mutability.ori
- LLVM Support: LLVM codegen for shadowing mutability change
- LLVM Rust Tests: ori_llvm/tests/binding_tests.rs — shadowing mutability change codegen
- AOT Tests: No AOT coverage yet

Error Messages

15D.4 Remove `dyn` Keyword for Trait Objects

Proposal: proposals/approved/remove-dyn-keyword-proposal.md

Remove the dyn keyword for trait objects. Trait names used directly as types mean “any value implementing this trait.”

// Before
@process (item: dyn Printable) -> void = ...
let items: [dyn Serializable] = ...

// After
@process (item: Printable) -> void = ...
let items: [Serializable] = ...

Implementation

15D.5 Index and Field Assignment

Proposal: proposals/approved/index-assignment-proposal.md

Extend assignment targets to support index expressions (list[i] = x), field access (state.name = x), mixed chains (state.items[i] = x, list[i].name = x), and compound assignment on all forms (list[i] += 1). All forms desugar to copy-on-write reassignment via IndexSet trait (for index) or struct spread (for fields).

let list = [1, 2, 3]
list[0] = 10                          // list = list.updated(key: 0, value: 10)

let state = GameState { score: 0, level: 1 }
state.score = 100                     // state = { ...state, score: 100 }
state.items[i] = new_item             // mixed chain
list[i].name = "new"                  // index then field

list[0] += 5                          // compound: list[0] = list[0] + 5

Phase 1: `IndexSet` Trait and `updated` Method

Implement: Define IndexSet<Key, Value> trait in prelude — @updated (self, key: Key, value: Value) -> Self
- Rust Tests: ori_types/src/infer/ — IndexSet trait resolution
- Ori Tests: tests/spec/traits/index_set/basic.ori
Implement: Register updated as built-in method on [T], {K: V}, [T, max N] in evaluator
- Rust Tests: ori_eval/src/method_dispatch/ — updated method dispatch
- Ori Tests: tests/spec/traits/index_set/updated_method.ori
Implement: updated with ARC-aware copy-on-write in ori_patterns/ori_eval
- Rust Tests: ori_patterns/src/value/ — copy-on-write behavior
- Ori Tests: tests/spec/traits/index_set/cow_behavior.ori

Phase 2: Parser Changes

Implement: Extend parser to accept assignment_target (identifier + index/field chains) on LHS of = and compound operators
- Rust Tests: ori_parse/src/grammar/expr/ — assignment target parsing
- Ori Tests: tests/spec/expressions/index_assignment_syntax.ori
Implement: Emit AST node capturing chain of index/field accesses in assignment target
- Rust Tests: ori_ir/src/ast/expr.rs — AssignTarget AST node
- Ori Tests: tests/spec/expressions/field_assignment_syntax.ori

Phase 3: Type-Directed Desugaring

Implement: Desugar [key] steps to updated() calls (requires IndexSet trait resolution)
- Rust Tests: ori_types/src/infer/expr/ — index assignment desugaring
- Ori Tests: tests/spec/expressions/index_assignment_desugar.ori
Implement: Desugar .field steps to struct spread reconstruction (requires struct type info)
- Rust Tests: ori_types/src/infer/expr/ — field assignment desugaring
- Ori Tests: tests/spec/expressions/field_assignment_desugar.ori
Implement: Handle nested cases, mixed field-index chains, and compound assignment
- Rust Tests: ori_types/src/infer/expr/ — mixed chain desugaring
- Ori Tests: tests/spec/expressions/mixed_chain_assignment.ori

Phase 4: Type Checker Integration

Phase 5: LLVM Support

LLVM Support: LLVM codegen for index assignment desugaring
- LLVM Rust Tests: ori_llvm/tests/ — index assignment codegen
- AOT Tests: No AOT coverage yet
LLVM Support: LLVM codegen for field assignment desugaring
- LLVM Rust Tests: ori_llvm/tests/ — field assignment codegen
- AOT Tests: No AOT coverage yet
LLVM Support: LLVM codegen for compound assignment on extended targets
- LLVM Rust Tests: ori_llvm/tests/ — compound assignment codegen
- AOT Tests: No AOT coverage yet

15D.6 Mutable Self

Proposal: proposals/approved/mutable-self-proposal.md

Make self a mutable binding in method bodies with implicit mutation propagation back to the caller. Extends the existing field/index assignment desugaring pattern to method calls.

impl Cursor {
    @advance (self) -> void = {
        self.pos += 1
    }
}

cursor.advance()   // cursor is updated via desugaring

Phase 1: Self Mutability

Implement: Make self a mutable binding in method bodies (type checker)
- Rust Tests: ori_types/src/infer/ — self mutability in methods
- Ori Tests: tests/spec/methods/mutable_self_basic.ori
Implement: Mutation detection dataflow analysis (classify methods as mutating/non-mutating)
- Rust Tests: ori_types/src/infer/ — mutation classification
- Ori Tests: tests/spec/methods/mutation_detection.ori

Phase 2: Call-Site Desugaring

Phase 3: Caller Validation

Implement: Error when calling mutating method on immutable ($) binding
- Rust Tests: ori_types/src/infer/expr/ — immutable receiver error
- Ori Tests: tests/compile-fail/methods/mutating_on_immutable.ori
Implement: Diagnostics for mutation-related errors
- Rust Tests: ori_diagnostic/ — mutation error diagnostics
- Ori Tests: tests/compile-fail/methods/mutation_errors.ori

Phase 4: Trait Integration

Implement: Infer mutation classification across trait implementations
- Rust Tests: ori_types/src/infer/ — trait mutation consistency
- Ori Tests: tests/spec/traits/mutable_self_trait.ori
Implement: Conservative mutating classification for trait objects without local impls
- Rust Tests: ori_types/src/infer/ — trait object mutation
- Ori Tests: tests/spec/traits/mutable_self_trait_object.ori

Phase 5: Extension Support

Implement: Extension methods follow same mutation propagation rules
- Rust Tests: ori_types/src/infer/ — extension mutation propagation
- Ori Tests: tests/spec/methods/mutable_self_extension.ori

Phase 6: Evaluator

Implement: Evaluator support for mutable self in method bodies
- Rust Tests: ori_eval/src/ — mutable self evaluation
- Ori Tests: tests/spec/methods/mutable_self_eval.ori
Implement: Evaluator call-site desugaring (implicit reassignment)
- Rust Tests: ori_eval/src/ — call-site desugaring evaluation
- Ori Tests: tests/spec/methods/mutable_self_propagation.ori

Phase 7: LLVM Support

LLVM Support: LLVM codegen for mutable self desugaring
- LLVM Rust Tests: ori_llvm/tests/ — mutable self codegen
- AOT Tests: tests/spec/methods/mutable_self_aot.ori
LLVM Support: COW integration for self-mutating methods
- LLVM Rust Tests: ori_llvm/tests/ — mutable self COW codegen
- AOT Tests: tests/spec/methods/mutable_self_cow.ori

15D.7 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: Binding and type syntax proposals implemented

Section 15D: Bindings & Types

15D.1 Function-Level Contracts: pre() / post()

Key Design Decisions

Implementation

15D.2 as Conversion Syntax

Lexer

Parser

Type Checker

Codegen

Migration

15D.3 Simplified Bindings with $ for Immutability

Lexer

Parser

Semantic Analysis

Imports

Shadowing

Error Messages

15D.4 Remove dyn Keyword for Trait Objects

Implementation

15D.5 Index and Field Assignment

Phase 1: IndexSet Trait and updated Method

Phase 2: Parser Changes

Phase 3: Type-Directed Desugaring

Phase 4: Type Checker Integration

Phase 5: LLVM Support

15D.6 Mutable Self

Phase 1: Self Mutability

Phase 2: Call-Site Desugaring

Phase 3: Caller Validation

Phase 4: Trait Integration

Phase 5: Extension Support

Phase 6: Evaluator

Phase 7: LLVM Support

15D.7 Section Completion Checklist

15D.1 Function-Level Contracts: `pre()` / `post()`

15D.2 `as` Conversion Syntax

15D.3 Simplified Bindings with `$` for Immutability

15D.4 Remove `dyn` Keyword for Trait Objects

Phase 1: `IndexSet` Trait and `updated` Method