Claude/ephapax linear types e00 zs (#6)

* 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)

---------

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

Author: hyperpolymath

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"
+```

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"
+```

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.

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"
+```

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"
+```

library/common/collection/contains.md

@@ -0,0 +1,69 @@
+# Operation: contains
+
+## Interface Signature
+
+```
+contains: Collection[A], A -> Boolean
+```
+
+## Behavioral Semantics
+
+**Purpose**: Determines whether a collection contains a specific element.
+
+**Parameters**:
+- `collection`: The source collection of elements of type `A`
+- `element`: The element to search for
+
+**Return Value**: `true` if `element` is found in `collection`, otherwise `false`.
+
+**Properties**:
+- Empty collection: `contains([], x) = false` for all `x`
+- Single element match: `contains([x], x) = true`
+- Single element no match: `contains([x], y) = false` when `x ≠ y`
+- Can be expressed as: `contains(c, x) = greater_than(length(filter(c, e => equal(e, x))), 0)`
+
+**Edge Cases**:
+- Equality comparison semantics (reference vs value) is implementation-defined
+- Short-circuit evaluation (stop on first match) is implementation-defined
+- Search order and performance characteristics are implementation-defined
+
+## Executable Test Cases
+
+```yaml
+test_cases:
+  - input:
+      collection: [1, 2, 3, 4, 5]
+      element: 3
+    output: true
+    description: "Element is present in collection"
+
+  - input:
+      collection: [1, 2, 3, 4, 5]
+      element: 6
+    output: false
+    description: "Element is not present in collection"
+
+  - input:
+      collection: []
+      element: 1
+    output: false
+    description: "Empty collection contains no elements"
+
+  - input:
+      collection: [1]
+      element: 1
+    output: true
+    description: "Single element collection contains that element"
+
+  - input:
+      collection: ["a", "b", "c"]
+      element: "b"
+    output: true
+    description: "String element is present"
+
+  - input:
+      collection: [1, 2, 1, 3, 1]
+      element: 1
+    output: true
+    description: "Element appears multiple times (still returns true)"
+```