# Implementation Plan: Function Definitions

## Overview
Bottom-up implementation through the stack: token → ast → lexer → parser → evaluator → repl → integration tests. Each step maintains backward compatibility and follows TDD.

## Steps

### Step 1: Token layer (`token/token.go`)
- Add `Ident`, `Comma`, `Equals` constants to `Type` enum
- Update `String()` for new types
- No tests needed — pure data types

### Step 2: AST layer (`ast/ast.go`)
- Add `Ident` struct: `Name string`; implements `Node`
- Add `FuncCall` struct: `Name string`, `Args []Node`; implements `Node`
- Add `Statement` interface with sealed `stmt()` marker
- Add `ExprStmt` struct: `Expr Node`; implements `Statement`
- Add `FuncDef` struct: `Name string`, `Params []string`, `Body Node`; implements `Statement`
- No tests needed — pure data types

### Step 3: Lexer (`lexer/lexer.go`)
- Add `isLetter(ch byte) bool` helper
- Before the single-char switch, add branch: if `isLetter(ch)`, scan identifier (letter then letters/digits), emit `Ident` token
- Add `','` → `Comma` and `'='` → `Equals` to single-char switch
- **Tests:** identifiers (`x`, `foo`, `f1`), comma, equals, full definition `f(x) = x + 1`, call `f(1, 2)`, mixed with numbers

### Step 4: Parser (`parser/parser.go`)
- Extend `factor()`:
  - `Ident` followed by `LParen` → parse `FuncCall`: consume `(`, parse args as comma-separated exprs, consume `)`
  - `Ident` not followed by `LParen` → return `&ast.Ident{Name}`
- Add `parseFuncDef()`: expects `Ident(` params `) = expr`
- Add `ParseLine(tokens) (Statement, error)`:
  - Scan for `Equals` token (not inside parens)
  - If found → `parseFuncDef()` → `*ast.FuncDef`
  - If not → `expr()` → `*ast.ExprStmt{Expr}`
- Keep `Parse()` unchanged for backward compat
- **Tests:** ParseLine for defs and exprs, factor for ident and func call, error cases

### Step 5: Evaluator (`evaluator/evaluator.go`)
- Add `Evaluator` struct with `funcs map[string]*ast.FuncDef`
- `New() *Evaluator`
- `Define(def *ast.FuncDef) error` — error on redefinition
- `Eval(node ast.Node, env map[string]float64) (float64, error)`:
  - `*ast.NumberLit` → return value
  - `*ast.BinaryExpr` → recurse left/right with same env
  - `*ast.Ident` → lookup in env, error if not found
  - `*ast.FuncCall` → lookup func, eval args in caller env, bind params, eval body in new env
- Keep package-level `Eval(node) (float64, error)` as backward-compat wrapper
- **Tests:** all existing tests still pass, new tests for Ident, FuncCall, Define, errors

### Step 6: REPL (`repl/repl.go`)
- In `Run()`: create `evaluator.New()` before loop
- Replace `evalLine()` with inline logic using `ParseLine()`
- `*ast.FuncDef` → `ev.Define(def)`, print `"defined <name>"`
- `*ast.ExprStmt` → `ev.Eval(stmt.Expr, nil)`, print result
- **Tests:** define + call across lines, redefine error, undefined func error

### Step 7: Integration tests (`integration_test.go`)
- Update `eval()`/`evalErr()` helpers to use `Evaluator` struct
- Add tests:
  - Define and call single-param function
  - Define and call multi-param function
  - Cross-function calls
  - Nested function calls in expressions
  - Error: undefined function
  - Error: wrong argument count
  - Error: function redefinition
  - Error: undefined variable

## Backward Compatibility
- `Parse()` remains unchanged — returns `ast.Node`
- Package-level `Eval()` remains — wraps `New().Eval(node, nil)`
- Existing tests must continue to pass at every step