Claude/ephapax linear types e00 zs (#7)

* feat: Initial Ephapax language implementation

Ephapax is a linear type system for safe memory management
targeting WebAssembly.

This commit includes:

Core Implementation:
- ephapax-syntax: AST definitions with linear type annotations
- ephapax-typing: Linear type checker with region support
- ephapax-wasm: WASM code generator with bump allocation
- ephapax-runtime: no_std WASM runtime with region management

Formal Semantics (Coq):
- Syntax.v: Core type and expression definitions
- Typing.v: Linear typing rules with context tracking
- Semantics.v: Operational semantics and safety theorems

Documentation:
- Language specification (spec/SPEC.md)
- Comprehensive wiki documentation
- ROADMAP.md with detailed development plan
- CONTRIBUTING.adoc guide

Infrastructure:
- Cargo workspace with 4 crates
- CI/CD workflow for Rust and Coq
- EUPL-1.2 license

Key features:
- Linear types prevent use-after-free and memory leaks
- Region-based memory management for bulk deallocation
- Second-class borrows for temporary access
- Formal proofs in Coq for type safety

* feat(frontend): Add lexer and parser for Ephapax language

Implements Phase 2 (Language Frontend) of the Ephapax roadmap:

- ephapax-lexer: High-performance lexer using logos
  - Tokenizes all Ephapax syntax (keywords, operators, literals)
  - Support for nested block comments {- -}
  - String escape sequence handling
  - Comprehensive error recovery
  - 20+ unit tests

- ephapax-parser: Parser combinator implementation using chumsky
  - Complete expression parsing (let, fn, if, region, case, etc.)
  - Type parsing (base types, String@region, functions, products, sums)
  - Declaration parsing (fn, type)
  - Rich error reporting with ariadne
  - 19 unit tests + doc tests

All tests pass successfully.

* feat(backend): Add interpreter, REPL, CLI, and standard library

- Complete ephapax-typing with full expression type checking
  (pair, sum types, case, let, string operations)
- Add ephapax-interp tree-walking interpreter for debugging
- Create ephapax-repl with interactive REPL and commands
  (:help, :type, :load, :tokens, :reset, :verbose)
- Build ephapax-cli with subcommands (run, check, compile, repl)
- Add ephapax-stdlib with prelude, I/O, string, math modules
- Add compile_module function to ephapax-wasm

* chore: Add library folder structure for common and specific libraries

Set up directory structure for Ephapax libraries:
- library/common/ for shared language implementations
- library/specific/ for Ephapax-specific code

* feat(library): Add common and specific library specifications

Common Library (from aggregate-library):
- arithmetic: add, subtract, multiply, divide, modulo
- comparison: less_than, greater_than, equal, not_equal, etc.
- logical: and, or, not
- string: concat, length, substring
- collection: map, filter, fold, contains
- conditional: if_then_else

Ephapax-Specific Library:
- linear: move, drop, copy (linear type operations)
- region: new_region, alloc_in (region-based memory)
- memory: borrow (reference operations)
- wasm: compile_to_wasm (WebAssembly compilation)

* refactor(library): Reorganize as aggregate-library with common + ephapax

Renamed library/ to aggregate-library/ with clearer structure:

Common Library (22 ops from hyperpolymath/aggregate-library):
- arithmetic: add, subtract, multiply, divide, modulo
- comparison: equal, not_equal, less_than, greater_than, less_equal, greater_equal
- logical: and, or, not
- string: concat, length, substring
- collection: map, filter, fold, contains
- conditional: if_then_else

Ephapax-Specific Library (17 ops):
- linear: move, drop, copy, borrow
- region: new_region, alloc_in
- io: print, println, read_line
- conversion: i32_to_string, string_to_i32
- product: pair, fst, snd
- sum: inl, inr, case

Total: 39 fully-specified operations

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

aggregate-library/README.md

@@ -0,0 +1,67 @@
+# Ephapax Aggregate Library
+
+The complete standard library for Ephapax = Common Library + Ephapax-Specific Library.
+
+## Structure
+
+```
+aggregate-library/
+├── common/              # Common Library (22 operations)
+│   ├── arithmetic/      # add, subtract, multiply, divide, modulo
+│   ├── comparison/      # equal, not_equal, less_than, greater_than, less_equal, greater_equal
+│   ├── logical/         # and, or, not
+│   ├── string/          # concat, length, substring
+│   ├── collection/      # map, filter, fold, contains
+│   └── conditional/     # if_then_else
+│
+└── ephapax/             # Ephapax-Specific Library (17 operations)
+    ├── linear/          # move, drop, copy, borrow
+    ├── region/          # new_region, alloc_in
+    ├── io/              # print, println, read_line
+    ├── conversion/      # i32_to_string, string_to_i32
+    ├── product/         # pair, fst, snd
+    └── sum/             # inl, inr, case
+```
+
+## Common Library
+
+Universal operations shared across all languages in the aggregate-library ecosystem. These 22 operations represent the intersection of functionality across radically different programming paradigms.
+
+Source: https://github.com/hyperpolymath/aggregate-library
+
+## Ephapax-Specific Library
+
+Operations unique to Ephapax's linear type system and region-based memory management:
+
+### Linear Types (4 operations)
+- `move` - Transfer ownership of linear values
+- `drop` - Explicitly consume linear values
+- `copy` - Duplicate unrestricted values
+- `borrow` - Create temporary references
+
+### Regions (2 operations)
+- `new_region` - Create scoped memory regions
+- `alloc_in` - Allocate in specific regions
+
+### I/O (3 operations)
+- `print` - Output string without newline
+- `println` - Output string with newline
+- `read_line` - Read line from stdin
+
+### Conversion (2 operations)
+- `i32_to_string` - Integer to string
+- `string_to_i32` - Parse string as integer
+
+### Product Types (3 operations)
+- `pair` - Construct pairs
+- `fst` - Extract first element
+- `snd` - Extract second element
+
+### Sum Types (3 operations)
+- `inl` - Inject left
+- `inr` - Inject right
+- `case` - Pattern match on sum
+
+## Total: 39 Operations
+
+Combined, the Ephapax standard library provides 39 fully-specified operations.

aggregate-library/common/arithmetic/add.md

@@ -0,0 +1,51 @@
+# Operation: add
+
+## Interface Signature
+
+```
+add: Number, Number -> Number
+```
+
+## Behavioral Semantics
+
+**Purpose**: Computes the sum of two numbers.
+
+**Parameters**:
+- `a`: The first number (augend)
+- `b`: The second number (addend)
+
+**Return Value**: The arithmetic sum of `a` and `b`.
+
+**Properties**:
+- Commutative: `add(a, b) = add(b, a)`
+- Associative: `add(add(a, b), c) = add(a, add(b, c))`
+- Identity element: `add(a, 0) = a`
+
+**Edge Cases**:
+- Overflow/underflow behavior is implementation-defined (Standard Library concern)
+- NaN and infinity handling is implementation-defined (Standard Library concern)
+
+## Executable Test Cases
+
+```yaml
+test_cases:
+  - input: [2, 3]
+    output: 5
+    description: "Basic addition of positive integers"
+
+  - input: [-5, 3]
+    output: -2
+    description: "Addition with negative number"
+
+  - input: [0, 0]
+    output: 0
+    description: "Addition of zeros"
+
+  - input: [1.5, 2.5]
+    output: 4.0
+    description: "Addition of decimal numbers"
+
+  - input: [-10, -20]
+    output: -30
+    description: "Addition of two negative numbers"
+```

aggregate-library/common/arithmetic/divide.md

@@ -0,0 +1,61 @@
+# Operation: divide
+
+## Interface Signature
+
+```
+divide: Number, Number -> Number
+```
+
+## Behavioral Semantics
+
+**Purpose**: Computes the quotient of two numbers.
+
+**Parameters**:
+- `a`: The dividend (number to be divided)
+- `b`: The divisor (number by which to divide)
+
+**Return Value**: The arithmetic quotient `a ÷ b`.
+
+**Properties**:
+- Non-commutative: `divide(a, b) ≠ divide(b, a)` (in general)
+- Identity element: `divide(a, 1) = a`
+- Inverse of multiplication: `divide(multiply(a, b), b) = a` (when `b ≠ 0`)
+
+**Preconditions**:
+- `b ≠ 0` (division by zero behavior is implementation-defined)
+
+**Edge Cases**:
+- Division by zero is implementation-defined (Standard Library concern)
+  - May return error, infinity, or NaN depending on language
+- Integer vs floating-point division is implementation-defined
+- Overflow/underflow behavior is implementation-defined
+- NaN and infinity handling is implementation-defined
+
+## Executable Test Cases
+
+```yaml
+test_cases:
+  - input: [6, 2]
+    output: 3
+    description: "Basic division with exact result"
+
+  - input: [7, 2]
+    output: 3.5
+    description: "Division with fractional result"
+
+  - input: [0, 5]
+    output: 0
+    description: "Zero divided by non-zero"
+
+  - input: [-10, 2]
+    output: -5
+    description: "Division with negative dividend"
+
+  - input: [10, -2]
+    output: -5
+    description: "Division with negative divisor"
+
+  - input: [-12, -3]
+    output: 4
+    description: "Division of two negative numbers"
+```

aggregate-library/common/arithmetic/modulo.md

@@ -0,0 +1,59 @@
+# Operation: modulo
+
+## Interface Signature
+
+```
+modulo: Number, Number -> Number
+```
+
+## Behavioral Semantics
+
+**Purpose**: Computes the remainder of division of two numbers.
+
+**Parameters**:
+- `a`: The dividend (number to be divided)
+- `b`: The divisor (number by which to divide)
+
+**Return Value**: The remainder when `a` is divided by `b`.
+
+**Properties**:
+- Non-commutative: `modulo(a, b) ≠ modulo(b, a)` (in general)
+- `modulo(a, b)` has the same sign as the divisor in most implementations
+- For positive integers: `0 ≤ modulo(a, b) < b` when `b > 0`
+
+**Preconditions**:
+- `b ≠ 0` (modulo by zero behavior is implementation-defined)
+
+**Edge Cases**:
+- Modulo by zero is implementation-defined (Standard Library concern)
+- Sign of result with negative operands is implementation-defined
+  - Some languages use truncated division (result has sign of dividend)
+  - Others use floored division (result has sign of divisor)
+- Behavior with floating-point numbers is implementation-defined
+
+## Executable Test Cases
+
+```yaml
+test_cases:
+  - input: [7, 3]
+    output: 1
+    description: "Basic modulo with positive integers"
+
+  - input: [10, 5]
+    output: 0
+    description: "Modulo with no remainder"
+
+  - input: [15, 4]
+    output: 3
+    description: "Modulo returning non-zero remainder"
+
+  - input: [0, 5]
+    output: 0
+    description: "Zero modulo non-zero"
+
+  - input: [100, 7]
+    output: 2
+    description: "Modulo with larger numbers"
+```
+
+**Note**: Test cases with negative numbers are omitted due to implementation-defined behavior across languages.

aggregate-library/common/arithmetic/multiply.md

@@ -0,0 +1,57 @@
+# Operation: multiply
+
+## Interface Signature
+
+```
+multiply: Number, Number -> Number
+```
+
+## Behavioral Semantics
+
+**Purpose**: Computes the product of two numbers.
+
+**Parameters**:
+- `a`: The multiplicand (first factor)
+- `b`: The multiplier (second factor)
+
+**Return Value**: The arithmetic product `a × b`.
+
+**Properties**:
+- Commutative: `multiply(a, b) = multiply(b, a)`
+- Associative: `multiply(multiply(a, b), c) = multiply(a, multiply(b, c))`
+- Identity element: `multiply(a, 1) = a`
+- Zero property: `multiply(a, 0) = 0`
+- Distributive over addition: `multiply(a, add(b, c)) = add(multiply(a, b), multiply(a, c))`
+
+**Edge Cases**:
+- Overflow/underflow behavior is implementation-defined (Standard Library concern)
+- NaN and infinity handling is implementation-defined (Standard Library concern)
+
+## Executable Test Cases
+
+```yaml
+test_cases:
+  - input: [2, 3]
+    output: 6
+    description: "Basic multiplication of positive integers"
+
+  - input: [-5, 3]
+    output: -15
+    description: "Multiplication with negative number"
+
+  - input: [0, 42]
+    output: 0
+    description: "Multiplication by zero"
+
+  - input: [7, 1]
+    output: 7
+    description: "Multiplication by one (identity)"
+
+  - input: [2.5, 4]
+    output: 10.0
+    description: "Multiplication with decimal number"
+
+  - input: [-3, -4]
+    output: 12
+    description: "Multiplication of two negative numbers"
+```

aggregate-library/common/arithmetic/subtract.md

@@ -0,0 +1,55 @@
+# Operation: subtract
+
+## Interface Signature
+
+```
+subtract: Number, Number -> Number
+```
+
+## Behavioral Semantics
+
+**Purpose**: Computes the difference between two numbers.
+
+**Parameters**:
+- `a`: The minuend (number from which another is subtracted)
+- `b`: The subtrahend (number to be subtracted)
+
+**Return Value**: The arithmetic difference `a - b`.
+
+**Properties**:
+- Non-commutative: `subtract(a, b) ≠ subtract(b, a)` (in general)
+- Identity element: `subtract(a, 0) = a`
+- Inverse of addition: `subtract(add(a, b), b) = a`
+
+**Edge Cases**:
+- Overflow/underflow behavior is implementation-defined (Standard Library concern)
+- NaN and infinity handling is implementation-defined (Standard Library concern)
+
+## Executable Test Cases
+
+```yaml
+test_cases:
+  - input: [5, 3]
+    output: 2
+    description: "Basic subtraction of positive integers"
+
+  - input: [3, 5]
+    output: -2
+    description: "Subtraction resulting in negative number"
+
+  - input: [0, 0]
+    output: 0
+    description: "Subtraction of zeros"
+
+  - input: [-5, 3]
+    output: -8
+    description: "Subtracting positive from negative"
+
+  - input: [10.5, 2.5]
+    output: 8.0
+    description: "Subtraction of decimal numbers"
+
+  - input: [-10, -20]
+    output: 10
+    description: "Subtracting negative from negative"
+```