marple-lang 0.3.0__tar.gz

marple_lang-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Romilly Cocking
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

marple_lang-0.3.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: marple-lang
+Version: 0.3.0
+Summary: Mini APL in Python Language Experiment. Uses APL arrays as the internal data model.
+Author-email: Romilly Cocking <romilly.cocking@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/romilly/marple
+Project-URL: Repository, https://github.com/romilly/marple.git
+Project-URL: Issues, https://github.com/romilly/marple/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pyright; extra == "test"
+Requires-Dist: PyHamcrest; extra == "test"
+Dynamic: license-file
+
+# marple
+
+Mini APL in Python Language Experiment. A first-generation APL interpreter with the rank operator, namespaces, and Python FFI. Uses APL arrays (shape + flat data) as the internal data model. Inspired by Rodrigo Girão Serrão's [RGSPL](https://github.com/rodrigogiraoserrano/RGSPL) and Iverson's [Dictionary of APL](https://www.jsoftware.com/papers/APLDictionary.htm).
+
+## Documentation
+
+More extensive documentation is available [here](https://romilly.github.io/marple/) 
+
+## Features
+
+- **40+ primitive functions** — arithmetic, comparison, boolean, structural, circular/trig, match/tally, membership
+- **Operators** — reduce (`/`), scan (`\`), inner product (`f.g`), outer product (`∘.f`), **rank** (`⍤`)
+- **Rank operator** — `(f⍤k)` applies any function along any axis: `(⌽⍤1) M` reverses rows, `(+/⍤1) M` sums rows
+- **From function** (`⌷`) — leading-axis selection that composes with rank
+- **Direct functions (dfns)** — `{⍵}` syntax with guards, recursion via `∇`, default `⍺`
+- **Symbol table-aware parser** — named functions work without parens: `double ⍳5`
+- **Namespaces** — `$::str::upper 'hello'`, `#import` directives, `::` separator
+- **I-beam operator** (`⌶`) — Python FFI for extending MARPLE with Python code
+- **Error handling** — `⎕EA` (execute alternate), `⎕EN` (error number), `⎕DM` (diagnostic message), `⎕SIGNAL`
+- **System variables** — `⎕IO`, `⎕CT`, `⎕PP`, `⎕RL`, `⎕A`, `⎕D`, `⎕TS`, `⎕WSID`, `⎕UCS`, `⎕NC`, `⎕EX`
+- **Matrices** — reshape, transpose, bracket indexing (`M[r;c]` any rank), matrix inverse (`⌹`)
+- **Numpy backend** — automatic vectorization (73x faster for element-wise, 380x for outer product), with pure-Python fallback
+- **Web REPL** — browser-based REPL at `http://localhost:8888/`, Pico W-ready
+- **Terminal REPL** — live backtick→glyph input, workspace save/load, APL-style formatting
+- **Script runner** — `marple script.marple` with session transcript output
+- **426 tests**, pyright strict, no external runtime dependencies
+
+## Quick start
+
+```bash
+pip install -e .
+marple
+```
+
+```
+MARPLE v0.2.11 - Mini APL in Python
+CLEAR WS
+
+      ⍳5
+1 2 3 4 5
+      +/⍳100
+5050
+      fact←{⍵≤1:1⋄⍵×∇ ⍵-1}
+      fact 10
+3628800
+      double←{⍵+⍵}
+      double ⍳5
+2 4 6 8 10
+      M←3 4⍴⍳12
+      (⌽⍤1) M
+ 4  3  2  1
+ 8  7  6  5
+12 11 10  9
+      $::str::upper 'hello'
+HELLO
+```
+
+### Running scripts
+
+```bash
+marple examples/01_primitives.marple          # run and display
+marple examples/01_primitives.marple > out.txt  # capture session transcript
+```
+
+Four demo scripts are included in `examples/`:
+- `01_primitives.marple` — arithmetic, vectors, matrices, reduce, products
+- `02_dfns.marple` — user functions, guards, recursion, rank operator
+- `03_namespaces.marple` — system library, imports, file I/O, i-beams
+- `04_errors.marple` — ea/en error handling, error codes
+
+### APL character input
+
+If you have a Dyalog APL keyboard layout installed (e.g. via `setxkbmap` with `grp:win_switch`), you can use the Win key to type APL glyphs directly.
+
+Alternatively, type APL glyphs using backtick prefixes — they appear immediately as you type:
+
+| Key | Glyph | Key | Glyph | Key | Glyph | Key | Glyph |
+|-----|-------|-----|-------|-----|-------|-----|-------|
+| `` `r `` | ⍴ | `` `i `` | ⍳ | `` `l `` | ← | `` `w `` | ⍵ |
+| `` `a `` | ⍺ | `` `V `` | ∇ | `` `x `` | ⋄ | `` `c `` | ⍝ |
+| `` `- `` | × | `` `= `` | ÷ | `` `< `` | ≤ | `` `> `` | ≥ |
+| `` `/ `` | ≠ | `` `o `` | ○ | `` `* `` | ⍟ | `` `2 `` | ¯ |
+| `` `q `` | ⌽ | `` `Q `` | ⍉ | `` `g `` | ⍋ | `` `G `` | ⍒ |
+| `` `t `` | ↑ | `` `y `` | ↓ | `` `n `` | ⊤ | `` `N `` | ⊥ |
+| `` `J `` | ⍤ | `` `I `` | ⌷ | `` `j `` | ∘ | `` `D `` | ⌹ |
+| `` `B `` | ⌶ | | | | | | |
+
+### System commands
+
+| Command | Action |
+|---------|--------|
+| `)off` | Exit |
+| `)clear` | Clear workspace |
+| `)wsid [name]` | Show or set workspace ID |
+| `)save [name]` | Save workspace (sets WSID if name given) |
+| `)load name` | Load workspace |
+| `)lib` | List saved workspaces |
+| `)fns [ns]` | List defined functions (optionally in namespace) |
+| `)vars` | List defined variables |
+
+## Development
+
+```bash
+pip install -e .[test]
+pytest
+pyright src/
+```
+
+To run without numpy (pure-Python mode):
+```bash
+MARPLE_BACKEND=none pytest
+```
+
+## Architecture
+
+| Module | Purpose |
+|--------|---------|
+| `arraymodel.py` | `APLArray(shape, data)` — the core data structure |
+| `backend.py` | Numpy/CuPy/ulab detection with pure-Python fallback |
+| `tokenizer.py` | Lexer for APL glyphs, numbers, strings, qualified names |
+| `parser.py` | Right-to-left recursive descent with symbol table |
+| `interpreter.py` | Tree-walking evaluator with dfn closures |
+| `functions.py` | Scalar functions with pervasion (numpy-accelerated) |
+| `structural.py` | Shape-manipulating and indexing functions |
+| `cells.py` | Cell decomposition and reassembly for the rank operator |
+| `namespace.py` | Hierarchical namespace resolution and system workspace |
+| `errors.py` | APL error classes with numeric codes |
+| `repl.py` | Interactive read-eval-print loop |
+| `script.py` | Script runner with session transcript output |
+| `terminal.py` | Raw terminal input with live glyph translation |
+| `glyphs.py` | Backtick → APL character mapping |
+| `workspace.py` | Directory-based workspace persistence |
+| `stdlib/` | Standard library: string, I/O, and error handling |
+
+## References
+
+- [RGSPL](https://github.com/rodrigogiraoserrano/RGSPL) — Rodrigo Girão Serrão's Python APL interpreter (design reference)
+- [RGSPL blog series](https://mathspp.com/blog/lsbasi-apl-part1) — step-by-step interpreter build
+- [Iverson's Dictionary of APL](https://www.jsoftware.com/papers/APLDictionary.htm) — the rank operator and leading-axis theory
+- [Language spec](docs/MARPLE_Language_Reference.md) — full first-generation APL reference and roadmap
+- [Rank operator spec](docs/MARPLE_Rank_Operator.md) — detailed rank operator design
+- [Indexing spec](docs/MARPLE_Indexing.md) — From function and indexing approach
+- [Namespaces spec](docs/MARPLE_Namespaces_And_IBeams.md) — namespaces, i-beams, and standard library

marple_lang-0.3.0/README.md

@@ -0,0 +1,143 @@
+# marple
+
+Mini APL in Python Language Experiment. A first-generation APL interpreter with the rank operator, namespaces, and Python FFI. Uses APL arrays (shape + flat data) as the internal data model. Inspired by Rodrigo Girão Serrão's [RGSPL](https://github.com/rodrigogiraoserrano/RGSPL) and Iverson's [Dictionary of APL](https://www.jsoftware.com/papers/APLDictionary.htm).
+
+## Documentation
+
+More extensive documentation is available [here](https://romilly.github.io/marple/) 
+
+## Features
+
+- **40+ primitive functions** — arithmetic, comparison, boolean, structural, circular/trig, match/tally, membership
+- **Operators** — reduce (`/`), scan (`\`), inner product (`f.g`), outer product (`∘.f`), **rank** (`⍤`)
+- **Rank operator** — `(f⍤k)` applies any function along any axis: `(⌽⍤1) M` reverses rows, `(+/⍤1) M` sums rows
+- **From function** (`⌷`) — leading-axis selection that composes with rank
+- **Direct functions (dfns)** — `{⍵}` syntax with guards, recursion via `∇`, default `⍺`
+- **Symbol table-aware parser** — named functions work without parens: `double ⍳5`
+- **Namespaces** — `$::str::upper 'hello'`, `#import` directives, `::` separator
+- **I-beam operator** (`⌶`) — Python FFI for extending MARPLE with Python code
+- **Error handling** — `⎕EA` (execute alternate), `⎕EN` (error number), `⎕DM` (diagnostic message), `⎕SIGNAL`
+- **System variables** — `⎕IO`, `⎕CT`, `⎕PP`, `⎕RL`, `⎕A`, `⎕D`, `⎕TS`, `⎕WSID`, `⎕UCS`, `⎕NC`, `⎕EX`
+- **Matrices** — reshape, transpose, bracket indexing (`M[r;c]` any rank), matrix inverse (`⌹`)
+- **Numpy backend** — automatic vectorization (73x faster for element-wise, 380x for outer product), with pure-Python fallback
+- **Web REPL** — browser-based REPL at `http://localhost:8888/`, Pico W-ready
+- **Terminal REPL** — live backtick→glyph input, workspace save/load, APL-style formatting
+- **Script runner** — `marple script.marple` with session transcript output
+- **426 tests**, pyright strict, no external runtime dependencies
+
+## Quick start
+
+```bash
+pip install -e .
+marple
+```
+
+```
+MARPLE v0.2.11 - Mini APL in Python
+CLEAR WS
+
+      ⍳5
+1 2 3 4 5
+      +/⍳100
+5050
+      fact←{⍵≤1:1⋄⍵×∇ ⍵-1}
+      fact 10
+3628800
+      double←{⍵+⍵}
+      double ⍳5
+2 4 6 8 10
+      M←3 4⍴⍳12
+      (⌽⍤1) M
+ 4  3  2  1
+ 8  7  6  5
+12 11 10  9
+      $::str::upper 'hello'
+HELLO
+```
+
+### Running scripts
+
+```bash
+marple examples/01_primitives.marple          # run and display
+marple examples/01_primitives.marple > out.txt  # capture session transcript
+```
+
+Four demo scripts are included in `examples/`:
+- `01_primitives.marple` — arithmetic, vectors, matrices, reduce, products
+- `02_dfns.marple` — user functions, guards, recursion, rank operator
+- `03_namespaces.marple` — system library, imports, file I/O, i-beams
+- `04_errors.marple` — ea/en error handling, error codes
+
+### APL character input
+
+If you have a Dyalog APL keyboard layout installed (e.g. via `setxkbmap` with `grp:win_switch`), you can use the Win key to type APL glyphs directly.
+
+Alternatively, type APL glyphs using backtick prefixes — they appear immediately as you type:
+
+| Key | Glyph | Key | Glyph | Key | Glyph | Key | Glyph |
+|-----|-------|-----|-------|-----|-------|-----|-------|
+| `` `r `` | ⍴ | `` `i `` | ⍳ | `` `l `` | ← | `` `w `` | ⍵ |
+| `` `a `` | ⍺ | `` `V `` | ∇ | `` `x `` | ⋄ | `` `c `` | ⍝ |
+| `` `- `` | × | `` `= `` | ÷ | `` `< `` | ≤ | `` `> `` | ≥ |
+| `` `/ `` | ≠ | `` `o `` | ○ | `` `* `` | ⍟ | `` `2 `` | ¯ |
+| `` `q `` | ⌽ | `` `Q `` | ⍉ | `` `g `` | ⍋ | `` `G `` | ⍒ |
+| `` `t `` | ↑ | `` `y `` | ↓ | `` `n `` | ⊤ | `` `N `` | ⊥ |
+| `` `J `` | ⍤ | `` `I `` | ⌷ | `` `j `` | ∘ | `` `D `` | ⌹ |
+| `` `B `` | ⌶ | | | | | | |
+
+### System commands
+
+| Command | Action |
+|---------|--------|
+| `)off` | Exit |
+| `)clear` | Clear workspace |
+| `)wsid [name]` | Show or set workspace ID |
+| `)save [name]` | Save workspace (sets WSID if name given) |
+| `)load name` | Load workspace |
+| `)lib` | List saved workspaces |
+| `)fns [ns]` | List defined functions (optionally in namespace) |
+| `)vars` | List defined variables |
+
+## Development
+
+```bash
+pip install -e .[test]
+pytest
+pyright src/
+```
+
+To run without numpy (pure-Python mode):
+```bash
+MARPLE_BACKEND=none pytest
+```
+
+## Architecture
+
+| Module | Purpose |
+|--------|---------|
+| `arraymodel.py` | `APLArray(shape, data)` — the core data structure |
+| `backend.py` | Numpy/CuPy/ulab detection with pure-Python fallback |
+| `tokenizer.py` | Lexer for APL glyphs, numbers, strings, qualified names |
+| `parser.py` | Right-to-left recursive descent with symbol table |
+| `interpreter.py` | Tree-walking evaluator with dfn closures |
+| `functions.py` | Scalar functions with pervasion (numpy-accelerated) |
+| `structural.py` | Shape-manipulating and indexing functions |
+| `cells.py` | Cell decomposition and reassembly for the rank operator |
+| `namespace.py` | Hierarchical namespace resolution and system workspace |
+| `errors.py` | APL error classes with numeric codes |
+| `repl.py` | Interactive read-eval-print loop |
+| `script.py` | Script runner with session transcript output |
+| `terminal.py` | Raw terminal input with live glyph translation |
+| `glyphs.py` | Backtick → APL character mapping |
+| `workspace.py` | Directory-based workspace persistence |
+| `stdlib/` | Standard library: string, I/O, and error handling |
+
+## References
+
+- [RGSPL](https://github.com/rodrigogiraoserrano/RGSPL) — Rodrigo Girão Serrão's Python APL interpreter (design reference)
+- [RGSPL blog series](https://mathspp.com/blog/lsbasi-apl-part1) — step-by-step interpreter build
+- [Iverson's Dictionary of APL](https://www.jsoftware.com/papers/APLDictionary.htm) — the rank operator and leading-axis theory
+- [Language spec](docs/MARPLE_Language_Reference.md) — full first-generation APL reference and roadmap
+- [Rank operator spec](docs/MARPLE_Rank_Operator.md) — detailed rank operator design
+- [Indexing spec](docs/MARPLE_Indexing.md) — From function and indexing approach
+- [Namespaces spec](docs/MARPLE_Namespaces_And_IBeams.md) — namespaces, i-beams, and standard library

marple_lang-0.3.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "marple-lang"
+version = "0.3.0"
+description = "Mini APL in Python Language Experiment. Uses APL arrays as the internal data model."
+authors = [{name = "Romilly Cocking", email = "romilly.cocking@gmail.com"}]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers", 
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9", 
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = []
+
+[project.scripts]
+marple = "marple.repl:main"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0.0",
+    "pytest-cov",
+    "pyright",
+    "PyHamcrest",
+]
+
+[project.urls]
+Homepage = "https://github.com/romilly/marple"
+Repository = "https://github.com/romilly/marple.git"
+Issues = "https://github.com/romilly/marple/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+marple = ["web/static/*.html", "stdlib/**/*.apl"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"

marple_lang-0.3.0/setup.cfg

@@ -0,0 +1,10 @@
+[metadata]
+license_files = LICENSE
+
+[bdist_wheel]
+universal = 1
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

marple_lang-0.3.0/src/marple/__init__.py

@@ -0,0 +1,3 @@
+"""Marple - A Python project following TDD principles."""
+
+__version__ = "0.1.0"

marple_lang-0.3.0/src/marple/arraymodel.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+
+from marple.backend import is_numeric_array, np, to_array, to_list
+
+
+class APLArray:
+    def __init__(self, shape: list[int], data: Any) -> None:
+        self.shape = shape
+        self.data = to_array(data) if isinstance(data, list) else data
+
+    def is_scalar(self) -> bool:
+        return self.shape == []
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, APLArray):
+            return NotImplemented
+        if self.shape != other.shape:
+            return False
+        if is_numeric_array(self.data) and is_numeric_array(other.data):
+            return bool(np.array_equal(self.data, other.data))
+        return to_list(self.data) == to_list(other.data)
+
+    def __repr__(self) -> str:
+        if self.is_scalar():
+            return f"S({self.data[0]})"
+        data_list = to_list(self.data) if is_numeric_array(self.data) else self.data
+        return f"APLArray({self.shape}, {data_list})"
+
+
+def S(value: Any) -> APLArray:
+    return APLArray([], [value])

marple_lang-0.3.0/src/marple/backend.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+# Backend selection: environment variable overrides auto-detection
+_backend_name = os.environ.get("MARPLE_BACKEND", "auto")
+
+np: Any = None
+
+if _backend_name != "none":
+    try:
+        import cupy as np  # type: ignore[no-redef]
+    except ImportError:
+        try:
+            import numpy as np  # type: ignore[no-redef]
+        except ImportError:
+            try:
+                import ulab.numpy as np  # type: ignore[no-redef,import-not-found]
+            except ImportError:
+                try:
+                    from ulab import numpy as np  # type: ignore[no-redef,import-not-found]
+                except ImportError:
+                    np = None
+
+HAS_BACKEND: bool = np is not None
+
+
+def to_array(data: list[Any]) -> Any:
+    """Convert a Python list to an ndarray if numeric and backend is available."""
+    if not HAS_BACKEND or len(data) == 0:
+        return data
+    if not all(isinstance(x, (int, float)) for x in data):
+        return data
+    return np.array(data)
+
+
+def to_list(data: Any) -> list[Any]:
+    """Convert an ndarray to a Python list. Pass lists through unchanged."""
+    if isinstance(data, list):
+        return data
+    return data.tolist()  # type: ignore[union-attr]
+
+
+def is_numeric_array(data: Any) -> bool:
+    """Check if data is an ndarray from the active backend."""
+    if not HAS_BACKEND:
+        return False
+    return hasattr(data, "dtype")

marple_lang-0.3.0/src/marple/cells.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from marple.arraymodel import APLArray, S
+from marple.backend import to_list
+from marple.errors import LengthError
+
+
+def resolve_rank_spec(spec: APLArray) -> tuple[int, int, int]:
+    """Resolve rank spec to (monadic, left_dyadic, right_dyadic).
+
+    Scalar c     → (c, c, c)
+    2-vector b c → (c, b, c)
+    3-vector a b c → (a, b, c)
+    """
+    data = to_list(spec.data)
+    if spec.is_scalar():
+        c = int(data[0])
+        return (c, c, c)
+    if len(data) == 2:
+        b, c = int(data[0]), int(data[1])
+        return (c, b, c)
+    if len(data) == 3:
+        a, b, c = int(data[0]), int(data[1]), int(data[2])
+        return (a, b, c)
+    raise LengthError(f"Rank spec must be 1, 2, or 3 elements, got {len(data)}")
+
+
+def clamp_rank(k: int, r: int) -> int:
+    """Clamp cell rank k to [0, r]. Handle negative (complementary) rank."""
+    if k < 0:
+        k = r + k
+    return max(0, min(k, r))
+
+
+def decompose(array: APLArray, cell_rank: int) -> tuple[list[int], list[APLArray]]:
+    """Decompose array into cells of the given rank.
+
+    Returns (frame_shape, cells) where frame_shape is the leading axes
+    and cells is a list of APLArray objects in row-major frame order.
+    """
+    r = len(array.shape)
+    k = clamp_rank(cell_rank, r)
+    frame_shape = array.shape[:r - k] if k < r else []
+    cell_shape = array.shape[r - k:] if k > 0 else []
+    cell_size = 1
+    for s in cell_shape:
+        cell_size *= s
+    if cell_size == 0:
+        cell_size = 1
+    data = to_list(array.data)
+    n_cells = 1
+    for s in frame_shape:
+        n_cells *= s
+    if n_cells == 0:
+        n_cells = 1
+    cells: list[APLArray] = []
+    for i in range(n_cells):
+        cell_data = data[i * cell_size : (i + 1) * cell_size]
+        cells.append(APLArray(list(cell_shape), cell_data))
+    return (list(frame_shape), cells)
+
+
+def reassemble(frame_shape: list[int], cells: list[APLArray]) -> APLArray:
+    """Reassemble cells into a single array.
+
+    If all cells have the same shape, result shape is frame_shape + cell_shape.
+    If shapes differ, pad with fill elements to max shape.
+    """
+    if len(cells) == 0:
+        return APLArray(frame_shape + [0], [])
+    if len(cells) == 1 and frame_shape == []:
+        return cells[0]
+    # Determine max cell shape
+    max_rank = max(len(c.shape) for c in cells)
+    max_shape: list[int] = [0] * max_rank
+    for c in cells:
+        # Pad cell shape on the left with 1s to match max_rank
+        padded = [1] * (max_rank - len(c.shape)) + c.shape
+        for j in range(max_rank):
+            max_shape[j] = max(max_shape[j], padded[j])
+    # Check if all cells match max_shape (no padding needed)
+    all_uniform = all(c.shape == max_shape for c in cells)
+    if all_uniform:
+        all_data: list[object] = []
+        for c in cells:
+            all_data.extend(to_list(c.data))
+        return APLArray(frame_shape + max_shape, all_data)
+    # Padding needed
+    max_size = 1
+    for s in max_shape:
+        max_size *= s
+    # Determine fill value
+    is_char = any(
+        len(c.data) > 0 and isinstance(to_list(c.data)[0], str)
+        for c in cells
+    )
+    fill = " " if is_char else 0
+    all_data = []
+    for c in cells:
+        cell_data = to_list(c.data)
+        if c.shape == max_shape:
+            all_data.extend(cell_data)
+        else:
+            # Pad: embed cell data in a max_shape-sized block
+            padded_cell: list[object] = [fill] * max_size
+            # Simple case: 1D padding
+            for j, val in enumerate(cell_data):
+                padded_cell[j] = val
+            all_data.extend(padded_cell)
+    return APLArray(frame_shape + max_shape, all_data)

marple_lang-0.3.0/src/marple/errors.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+
+class APLError(Exception):
+    """Base class for APL errors."""
+    code: int = 0
+    name: str = "ERROR"
+
+    def __init__(self, message: str = "") -> None:
+        self.message = message
+        super().__init__(f"{self.name}: {message}" if message else self.name)
+
+
+class SyntaxError_(APLError):
+    code = 1
+    name = "SYNTAX ERROR"
+
+
+class ValueError_(APLError):
+    code = 2
+    name = "VALUE ERROR"
+
+
+class DomainError(APLError):
+    code = 3
+    name = "DOMAIN ERROR"
+
+
+class LengthError(APLError):
+    code = 4
+    name = "LENGTH ERROR"
+
+
+class RankError(APLError):
+    code = 5
+    name = "RANK ERROR"
+
+
+class IndexError_(APLError):
+    code = 6
+    name = "INDEX ERROR"
+
+
+class LimitError(APLError):
+    code = 7
+    name = "LIMIT ERROR"
+
+
+class WSFullError(APLError):
+    code = 8
+    name = "WS FULL"
+
+
+class SecurityError(APLError):
+    code = 9
+    name = "SECURITY ERROR"
+
+
+class DependencyError(APLError):
+    code = 10
+    name = "DEPENDENCY ERROR"
+
+
+class ClassError(APLError):
+    code = 11
+    name = "CLASS ERROR"