lux/docs/ROADMAP.md

# Lux Development Roadmap

*Targeting practical use cases in priority order.*

---

## Feature Status Summary

### Schema Evolution
| Component | Status |
|-----------|--------|
| Parser (`@v1`, `@v2`, `from @v1 = ...`) | ✅ Complete |
| AST representation | ✅ Complete |
| Runtime versioned values | ✅ Complete |
| Schema registry & compatibility checking | ✅ Complete |
| Basic migration execution | ✅ Complete |
| Type system integration | ⚠️ Partial (versions ignored in typechecker) |
| Auto-migration generation | ❌ Missing |
| Serialization/codec support | ❌ Missing |

### Behavioral Types
| Component | Status |
|-----------|--------|
| Parser (`is pure`, `is total`, etc.) | ✅ Complete |
| AST & PropertySet | ✅ Complete |
| Pure function checking (no effects) | ✅ Complete |
| Total verification | ❌ Missing |
| Idempotent verification | ❌ Missing |
| Deterministic verification | ❌ Missing |
| Where clause enforcement | ❌ Missing |

---

## Use Case 1: Backend Services with Complex Business Logic

**Value Proposition:** Effect tracking shows exactly what each function does. Testing is trivial.

### Phase 1.1: Make It Buildable (Current Blockers)

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Generic type parameters | P0 | — | ✅ Complete |
| String interpolation | P1 | — | ✅ Complete |
| File effect (read/write) | P1 | — | ✅ Complete |
| HTTP effect (client) | P1 | — | ✅ Complete |
| JSON parsing/serialization | P1 | — | ✅ Complete |

### Phase 1.2: Database & Persistence

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| SQL effect (query, execute) | P1 | 2 weeks | ❌ Missing |
| Connection pooling | P2 | 1 week | ❌ Missing |
| Transaction effect | P2 | 1 week | ❌ Missing |

### Phase 1.3: Web Server Framework

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| HTTP server effect | P1 | 2 weeks | ✅ Complete |
| Routing DSL | P2 | 1 week | ❌ Missing |
| Middleware pattern | P2 | 1 week | ❌ Missing |
| Request/Response types | P1 | 3 days | ✅ Complete (via HttpServer effect) |

### Phase 1.4: Developer Experience

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Elm-quality error messages | P1 | 2 weeks | ⚠️ Partial (context shown, suggestions missing) |
| Full JS compilation | P2 | 4 weeks | ❌ Missing |
| Hot reload / watch mode | P2 | — | ✅ Complete |
| Debugger improvements | P3 | 2 weeks | ✅ Basic |
| C backend CLI integration | P1 | — | ✅ Complete (`lux compile`) |

### Success Criteria for Use Case 1
- [ ] Can build a REST API with database access
- [ ] Can swap database handler for testing without mocks
- [ ] Effect signatures document all side effects
- [ ] Compile-time guarantees prevent common bugs

---

## Use Case 2: High-Reliability Systems

**Value Proposition:** Behavioral types provide compile-time guarantees (`is total`, `is idempotent`).

### Phase 2.1: Complete Behavioral Type Verification

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Total function verification | P1 | 2 weeks | ❌ Missing |
| Idempotent verification | P1 | 2 weeks | ❌ Missing |
| Deterministic verification | P1 | 1 week | ❌ Missing |
| Where clause enforcement | P1 | 1 week | ❌ Missing |

**Implementation approach:**
- **Total:** Restrict to structural recursion, require termination proof for general recursion
- **Idempotent:** Pattern-based (setter patterns, specific effect combinations)
- **Deterministic:** Effect analysis (no Random, Time, or non-deterministic IO)

### Phase 2.2: Refinement Types (Stretch Goal)

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Basic refinements (`Int where self > 0`) | P2 | 3 weeks | ❌ Missing |
| SMT solver integration (Z3) | P3 | 4 weeks | ❌ Missing |
| Contract checking | P3 | 2 weeks | ❌ Missing |

### Phase 2.3: Fault Tolerance Patterns

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Retry effect with backoff | P2 | 1 week | ❌ Missing |
| Circuit breaker pattern | P2 | 1 week | ❌ Missing |
| Supervision trees (Elixir-style) | P3 | 3 weeks | ❌ Missing |

### Success Criteria for Use Case 2
- [ ] Compiler verifies `is total` functions always terminate
- [ ] Compiler verifies `is idempotent` functions are safe to retry
- [ ] Can build payment processing with idempotency guarantees
- [ ] Effect system enables fault isolation

---

## Use Case 3: Data Pipelines / ETL Systems

**Value Proposition:** Schema evolution handles changing data formats gracefully.

### Phase 3.1: Complete Schema Evolution

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Type system version tracking | P1 | 1 week | ⚠️ Partial |
| Auto-migration generation | P1 | 2 weeks | ❌ Missing |
| Version compatibility errors | P1 | 1 week | ❌ Missing |
| Migration chain optimization | P2 | 1 week | ⚠️ Basic |

### Phase 3.2: Serialization Support

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| JSON codec generation | P1 | 2 weeks | ❌ Missing |
| Version-aware deserialization | P1 | 1 week | ❌ Missing |
| Binary format support | P3 | 2 weeks | ❌ Missing |
| Avro/Protobuf interop | P3 | 3 weeks | ❌ Missing |

### Phase 3.3: Stream Processing

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Stream effect | P2 | 2 weeks | ❌ Missing |
| Batch processing patterns | P2 | 1 week | ❌ Missing |
| Backpressure handling | P3 | 2 weeks | ❌ Missing |

### Success Criteria for Use Case 3
- [ ] Can define versioned types with automatic migrations
- [ ] Compiler catches version mismatches
- [ ] Can deserialize old data formats automatically
- [ ] Can process data streams with effect tracking

---

## Use Case 4: Teaching Functional Programming

**Value Proposition:** Effects are more intuitive than monads for learning.

### Phase 4.1: Educational Materials

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Beginner tutorial (effects intro) | P1 | 1 week | ⚠️ Basic |
| Interactive examples | P2 | 1 week | ❌ Missing |
| Comparison guides (vs Haskell monads) | P2 | 3 days | ❌ Missing |
| Video tutorials | P3 | 2 weeks | ❌ Missing |

### Phase 4.2: REPL Improvements

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Step-by-step evaluation | P2 | 1 week | ❌ Missing |
| Effect visualization | P2 | 2 weeks | ❌ Missing |
| Type hole support (`_` placeholders) | P2 | 1 week | ❌ Missing |

### Phase 4.3: Error Message Excellence

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Elm-style error catalog | P1 | 2 weeks | ❌ Missing |
| "Did you mean?" suggestions | P1 | 1 week | ❌ Missing |
| Example-based hints | P2 | 1 week | ❌ Missing |
| Beginner-friendly mode | P3 | 1 week | ❌ Missing |

### Success Criteria for Use Case 4
- [ ] New FP learner can understand effects in < 1 hour
- [ ] Error messages guide toward solutions
- [ ] Clear progression from pure functions to effects to handlers

---

## Cross-Cutting Concerns (All Use Cases)

### Ecosystem

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| Package manager (lux pkg) | P1 | 3 weeks | ⚠️ Basic |
| Package registry | P2 | 2 weeks | ❌ Missing |
| Dependency resolution | P2 | 2 weeks | ❌ Missing |

### Tooling

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| LSP completions | P1 | 1 week | ⚠️ Basic |
| LSP go-to-definition | P1 | 1 week | ⚠️ Partial |
| Formatter | P2 | — | ✅ Complete |
| Documentation generator | P2 | 1 week | ❌ Missing |

### Compilation

| Task | Priority | Effort | Status |
|------|----------|--------|--------|
| C backend (basic) | P1 | — | ✅ Complete (functions, Console.print) |
| Extend C backend (closures, lists) | P1 | 2 weeks | ❌ Missing |
| JS backend | P2 | 4 weeks | ❌ Missing |
| WASM backend | P3 | 4 weeks | ❌ Missing |

---

## Recommended Implementation Order

### Quarter 1: Foundation ✅ COMPLETE

1. ~~**Generic type parameters**~~ ✅ Done
2. ~~**String interpolation**~~ ✅ Done
3. ~~**File effect**~~ ✅ Done
4. ~~**HTTP client effect**~~ ✅ Done
5. ~~**JSON support**~~ ✅ Done
6. **Elm-quality errors** — ⚠️ In progress

### Quarter 2: Backend Services (Use Case 1)

7. **HTTP server effect** — Build APIs
8. **SQL effect** — Database access
9. **Full JS compilation** — Deployment
10. **Package manager** — Code sharing

### Quarter 3: Reliability (Use Case 2)

11. **Behavioral type verification** — Total, idempotent, deterministic
12. **Where clause enforcement** — Type-level guarantees
13. **Schema evolution completion** — Version tracking in types
14. **Auto-migration generation** — Reduce boilerplate

### Quarter 4: Polish (Use Cases 3 & 4)

15. **Serialization codecs** — Data pipelines
16. **Educational materials** — Teaching
17. **Refinement types** — Advanced guarantees
18. **Stream processing** — ETL use case

---

## What's Already Done (Often Forgotten)

**Core Language:**
- ✅ Generic type parameters (`fn map<T, U>`, `type List<T>`)
- ✅ String interpolation (`"Hello {name}!"`)
- ✅ Pattern matching with exhaustiveness checking
- ✅ Algebraic data types
- ✅ Type inference (Hindley-Milner)
- ✅ Tail call optimization

**Effect System:**
- ✅ Effect declarations and handlers
- ✅ Console effect (print, readLine, readInt)
- ✅ File effect (read, write, exists, delete, listDir, mkdir)
- ✅ HTTP client effect (get, post, put, delete)
- ✅ HTTP server effect (listen, accept, respond, stop)
- ✅ Process effect (exec, env, args, cwd, exit)
- ✅ Random effect (int, float, range, bool)
- ✅ Time effect (now, sleep)
- ✅ Test effect (assert, assertEqual, assertTrue, assertFalse)

**Module System:**
- ✅ Imports, exports, aliases
- ✅ Selective imports (`import foo.{a, b}`)
- ✅ Wildcard imports (`import foo.*`)
- ✅ Circular dependency detection

**Standard Library:**
- ✅ String operations (split, join, trim, contains, replace, toUpper, toLower, etc.)
- ✅ List operations (map, filter, fold, head, tail, concat, reverse, find, etc.)
- ✅ Option operations (map, flatMap, getOrElse, isSome, isNone)
- ✅ Result operations (map, flatMap, getOrElse, isOk, isErr)
- ✅ Math operations (abs, min, max, sqrt, pow, floor, ceil, round)
- ✅ JSON parsing/serialization (parse, stringify, get, object, array)

**Tooling:**
- ✅ C backend (functions, Console.print, CLI: `lux compile`)
- ✅ REPL with history
- ✅ Basic LSP server
- ✅ Formatter
- ✅ Watch mode
- ✅ Debugger (basic)

**Advanced (Parsing Only):**
- ✅ Schema evolution (parsing, runtime values)
- ✅ Behavioral types (parsing, pure checking only)

---

## Success Metrics

### Use Case 1: Backend Services
- Can build and deploy a production API
- 10+ companies using Lux for backends

### Use Case 2: High-Reliability
- Compiler catches idempotency violations
- Used in fintech/healthcare context

### Use Case 3: Data Pipelines
- Schema migrations happen automatically
- Zero data loss from version mismatches

### Use Case 4: Teaching
- Featured in FP courses
- "Effects finally make sense" testimonials