basedpl 0.1.7__tar.gz → 0.1.8__tar.gz

{basedpl-0.1.7 → basedpl-0.1.8}/Cargo.lock

@@ -36,7 +36,7 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "basedpl"
-version = "0.1.7"
+version = "0.1.8"
 dependencies = [
  "anyhow",
  "async-trait",

{basedpl-0.1.7 → basedpl-0.1.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "basedpl"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 rust-version = "1.98"
 license = "Apache-2.0"

{basedpl-0.1.7 → basedpl-0.1.8}/DEV.md

@@ -34,8 +34,8 @@ CI uses the development profile for Rust and Python tests. Distribution wheels u
 - `lib/*.apl`: Dyalog dfns adapted from April and the Dyalog dfns workspace. Reference cases load these shared definitions with `•LOAD`; case-specific setup stays in each test. See `lib/README.md` for usage and provenance.
 - `array.rs`: ordinary `Value` atoms and immutable shared arrays; checked construction, recursive prototypes, axis offsets, direct/mapped result frames, cell descriptors, padded cell assembly and row-based display. Arrays retain function handles and cache lexical dependencies without owning lexical frames or Python objects.
 - `number.rs`: Integer/Exact/Float/Complex values, normalization, checked arithmetic, promotion, comparison and structural conversion. `i64` and BigRational share one exact domain. Checked integer overflow falls back to BigRational; integral rational results return to `i64` when they fit. Representation is private. Complex values use `num_complex::Complex64`, normalizing exactly zero imaginary parts to Float.
-- `agreement.rs`: leading/unit-axis broadcast shapes and index maps, shared by scalar functions, Each, rank frames and explicit scalar axes. Equal-shape and repeated-block mappings avoid general coordinate calculations. No expanded input copies.
-- `keyed.rs`: keyed arrays. `Keys` holds element names in ravel order with a name-to-position hash, stored in an optional field of the array. Every ordinary constructor leaves that field unset, so a primitive drops keys unless it reattaches them. `construct` and `merge` build keyed arrays, `align` puts two keyed arguments in one layout, and `retain` keeps keys on a positional result of the keyed argument's shape. Structural functions carry keys through `carry_keys` in `primitive.rs`. Dot access is a binder rewrite to Pick in `eval.rs`. The design and its decision log are in `meta/keyed.md`.
+- `agreement.rs`: positional broadcasting and key union through one output layout and two index maps. Scalar functions, Each, rank frames, native mathematical functions and explicit scalar axes use this path. Missing entries use prototype fill. Compact numeric kernels read the maps directly. Equal-shape and repeated-block mappings avoid coordinate calculations and expanded input copies. Contracted-axis maps require equal key sets and retain the first axis's order.
+- `keyed.rs`: axis-label construction, lookup and named updates. Each immutable `Keys` holds unique strings and a name-to-position hash. `Layout` in `array.rs` owns dimensions and keys together. Its axis selection, concatenation and replacement operations describe structural results. Frames and cells carry layouts into assembly, which retains cell-axis labels shared by all result cells. Dot access is a binder rewrite to Pick in `eval.rs`. The design is in `meta/axiskey.md`.
 - `primitive.rs`: primitive identities/glyphs, valences and array-level implementations. Replicate, products and assignment retain their own agreement rules. Allocation caps are separate from numeric-to-integer conversion.
 - `number_theory.rs`: segmented prime enumeration, Miller–Rabin primality and Brent/Pollard–rho factorisation; exact integer results and scalar-cell assembly.
 - `system.rs`: case-insensitive `•Name` table for constant arrays and native functions. System functions use ordinary function nodes and application. `primitive.rs` contains single-character primitives.

{basedpl-0.1.7 → basedpl-0.1.8}/PKG-INFO

@@ -1,14 +1,17 @@
 Metadata-Version: 2.4
 Name: basedpl
-Version: 0.1.7
+Version: 0.1.8
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastship>=0.0.11 ; extra == 'dev'
 Requires-Dist: maturin>=1.0,<2.0 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Requires-Dist: numpy ; extra == 'dev'
+Requires-Dist: pandas ; extra == 'dev'
 Requires-Dist: conkernelclient>=0.0.23 ; extra == 'dev'
+Requires-Dist: pandas ; extra == 'pandas'
 Provides-Extra: dev
+Provides-Extra: pandas
 License-File: LICENSE
 Summary: bAsedPL is an APL-derived array language, borrowing ideas from J and BQN, with an emphasis on simple, consistent notation.
 Author-email: Jeremy Howard <github@jhoward.fastmail.fm>

{basedpl-0.1.7 → basedpl-0.1.8}/docs/glyphs/colon.md

@@ -1,16 +1,19 @@
-# `:` — Guard
+# `:` — Unkey / Key / Guard
 
-`condition:result` returns `result` when the condition is true. Otherwise execution continues. Only the chosen result evaluates.
+`:Y` removes axis keys. `K:Y` labels leading axes. `K:[axes]Y` labels selected axes. See [axis keys](../keyed.md).
 
 ```apl
-{⍵<0:-⍵ ⋄ ⍵}¯4     ⍝ 4
-{⍵=0:0 ⋄ ÷⍵}0      ⍝ 0
+:('aa' 'bb':1 2)    ⍝ 1 2
+'bb'⊃'aa' 'bb':1 2 ⍝ 2
 ```
 
-Condition: Boolean singleton. An empty selected result returns no value. See [error guards](error-guard.md).
+Inside a dfn, group functional uses: `(K:Y)` or `(:Y)`.
 
-Inside parentheses, `key:value` names a value in a [keyed array](../keyed.md).
+`condition:result` returns `result` when the condition is true. Otherwise execution continues. Only the chosen result evaluates.
 
 ```apl
-'b'⊃('a':1 ⋄ 'b':2)   ⍝ 2
+{⍵<0:-⍵ ⋄ ⍵}¯4     ⍝ 4
+{⍵=0:0 ⋄ ÷⍵}0      ⍝ 0
 ```
+
+Condition: Boolean singleton. An empty selected result returns no value. See [error guards](error-guard.md).

{basedpl-0.1.7 → basedpl-0.1.8}/docs/glyphs/dot.md

@@ -12,7 +12,7 @@ Singleton contraction axes extend. Empty contractions use the reduction identity
 After an array, `.name` reads a [keyed array](../keyed.md) value: `T.name` is `'name'⊃T`. It also works as an assignment target.
 
 ```apl
-T←('n':1 ⋄ 'addr':('city':'Paris'))
+T←('n':1),('addr':'city':'Paris')
 T.addr.city        ⍝ 'Paris'
 T.n+←1 ⋄ T.n       ⍝ 2
 ```

{basedpl-0.1.7 → basedpl-0.1.8}/docs/glyphs/execute.md

@@ -7,11 +7,12 @@
 x←7 ⋄ ⍎'x+1'       ⍝ 8
 ```
 
-`X⍎Y` runs no code. It looks up key `Y` in the keyed array `X`, exactly as `Y⊃X` does.
+`X⍎Y` selects `Y⊃X`, using numeric coordinates or axis keys.
 
 ```apl
-T←('a':10 ⋄ 'b':20)
-T⍎'b'              ⍝ 20
+T←'aa' 'bb':10 20
+T⍎'bb'             ⍝ 20
+10 20⍎2            ⍝ 20
 ```
 
 Assignments and explicit output take effect in the current session.

{basedpl-0.1.7 → basedpl-0.1.8}/docs/glyphs/iota.md

@@ -13,10 +13,11 @@ A shape vector generates an array of coordinate vectors.
 ⍳2 2               ⍝ 2 2⍴(1 1⋄ 1 2⋄ 2 1⋄ 2 2)
 ```
 
-On a [keyed array](../keyed.md), `⍳` returns the keys with the array's shape.
+`⍳[axis]Y` returns that axis's keys, or `1…length` on an unkeyed axis. Several axes return a vector of selector vectors.
 
 ```apl
-⍳('price':1 ⋄ 'qty':2) ⍝ 'price' 'qty'
+⍳[1]('price' 'qty':1 2) ⍝ 'price' 'qty'
+⍳[2]2 3⍴0          ⍝ 1x 2x 3x
 ```
 
 `X⍳Y` finds the first matching major cell in `X` for each cell of `Y`. Not found: `1+≢X`. Uses tolerant matching and returns exact positions.

{basedpl-0.1.7 → basedpl-0.1.8}/docs/glyphs/mix.md

@@ -22,12 +22,12 @@ Array-valued coordinate fields pair using leading-axis agreement:
 (1 3)˘(2 4)⊃3 4⍴⍳12 ⍝ 2 12
 ```
 
-On a [keyed array](../keyed.md), a string picks the value stored under that key. An array of strings returns an ordinary array of values with the same shape.
+Coordinate fields may use strings on [keyed axes](../keyed.md).
 
 ```apl
-T←('price':1 2 3 ⋄ 'qty':4 5 6)
+T←'price' 'qty':(1 2 3 ⋄ 4 5 6)
 'qty'⊃T            ⍝ 4 5 6
-('qty' 'price')⊃T  ⍝ (4 5 6 ⋄ 1 2 3)
+(⊂'qty' 'price')⊃T ⍝ (4 5 6 ⋄ 1 2 3)
 ```
 
 On Mix, axes place cell dimensions among frame dimensions; fractional positions insert before an axis. INDEX: position outside the array. Index 1 on an empty axis gives fill, as does [First](take.md).

{basedpl-0.1.7 → basedpl-0.1.8}/docs/glyphs/parentheses.md

@@ -14,13 +14,6 @@ Separators construct nested vectors. A trailing separator makes a singleton.
 (1 2 ⋄ 3 4)        ⍝ (1 2)(3 4)
 ```
 
-`key:value` entries construct a [keyed array](../keyed.md). `()` is the empty keyed vector.
-
-```apl
-≢('a':1 ⋄ 'b':2)   ⍝ 2x
-≢()                ⍝ 0x
-```
-
 Two functions form an atop: `(f g)Y` is `f(g Y)`.
 
 ```apl

{basedpl-0.1.7 → basedpl-0.1.8}/docs/index.md

@@ -22,7 +22,7 @@ bAsedPL distinguishes two application rules. Structural mapping (arithmetic, Eac
 - [Python](python.md): sessions, arrays, NumPy and callable APL functions.
 - [Process interfaces](processes.md): JSON lines and interruptible workers.
 - [Language rules](rules.md): evaluation, numbers, agreement, axes and fill.
-- [Keyed arrays](keyed.md): named elements, lookup, agreement, assignment and Python dicts.
+- [Axis keys](keyed.md): named rows and columns, lookup, agreement, assignment and Python conversion.
 
 ## Glyph reference
 
@@ -75,7 +75,7 @@ Each name below links to its definitions and examples. Examples show an equivale
 | `⊆` [Nest](glyphs/nest.md) | Nest | Partition | |
 | `⊃` [Mix](glyphs/mix.md) | Mix | Pick | Monad as Dyalog `⎕ML≥2`. Pick takes cells: `2⊃2 3⍴⍳6` is `4 5 6`. A string picks by [key](keyed.md) |
 | `⌷` [Squad](glyphs/squad.md) | Identity | Index | |
-| `⍳` [Iota](glyphs/iota.md) | Index generator | Index of | Monad on a [keyed array](keyed.md) returns its keys |
+| `⍳` [Iota](glyphs/iota.md) | Index generator | Index of | `⍳[axes]Y` returns axis selectors |
 | `⍸` [Where](glyphs/where.md) | Where | Interval index | |
 | `∊` [Member](glyphs/member.md) | Enlist | Membership | |
 | `∪` [Union](glyphs/union.md) | Unique | Union | |
@@ -129,14 +129,14 @@ Each name below links to its definitions and examples. Examples show an equivale
 | `˘` [Strand](glyphs/strand.md) | Form a vector of values: `1˘+˘'abc'` |
 | `←` [Assign](glyphs/assign.md) | Assignment, including modified/indexed/selective forms |
 | `→` [Pipe](glyphs/pipe.md) | Left-to-right function application |
-| `(…)` [Parentheses](glyphs/parentheses.md) | Grouping / nested array literals / [keyed arrays](keyed.md) / trains |
+| `(…)` [Parentheses](glyphs/parentheses.md) | Grouping / nested array literals / trains |
 | `[…]` [Brackets](glyphs/brackets.md) | Enclosure, array literals, indexing and axes |
 | `;` [Semicolon](glyphs/semicolon.md) | Index-axis separator |
 | `{…}` [Braces](glyphs/braces.md) | Defined function or operator |
 | `⍺` [Alpha](glyphs/alpha.md), `⍵` [Omega](glyphs/omega.md) | Left / right argument |
 | `⍶` [Alpha underbar](glyphs/alpha-underbar.md), `⍹` [Omega underbar](glyphs/omega-underbar.md) | Left / right operand |
 | `∇` [Del](glyphs/del.md), `⍢` [Del diaeresis](glyphs/del-diaeresis.md) | Function / operator self-reference |
-| `:` [Colon](glyphs/colon.md), `::` [Error guard](glyphs/error-guard.md) | Boolean guard or [keyed](keyed.md) entry / error guard |
+| `:` [Colon](glyphs/colon.md), `::` [Error guard](glyphs/error-guard.md) | Unkey / key axes; Boolean guard / error guard inside dfns |
 | `⋄` [Diamond](glyphs/diamond.md) | Statement or literal separator |
 | `⍝` [Comment](glyphs/comment.md) | Comment |
 | `⎕←` [Quad](glyphs/quad.md) | Explicit output |
@@ -169,4 +169,4 @@ Index origin: 1. Comparison tolerance: `1E¯14`.
 - [Numbers](rules.md#numbers): bare numbers are approximate. `x` and `r` mark exact integers and rationals, as J: `1x÷3x` is `1r3`. Predicates, positions, tally and shape are exact.
 - [Agreement](rules.md#agreement-and-pervasion): scalar functions, Each and Rank align leading axes, and unit dimensions expand: `(2 3⍴⍳6)+10 20` is `2 3⍴11 12 13 24 25 26`.
 - [System names](#system-names): written `•NAME`, as BQN, not `⎕NAME`. Most Dyalog system functions and variables are not included.
-- Namespaces: none. [Keyed arrays](keyed.md) hold named data instead. `('a':1 ⋄ 'b':2)` evaluates its keys, so they are quoted. `T.a` is `'a'⊃T`, and `X⍎Y` is `Y⊃X`.
+- [Axis keys](keyed.md) name data. `K:Y` evaluates its keys. `T.a` is `'a'⊃T`, and `X⍎Y` is `Y⊃X`.

basedpl-0.1.8/docs/keyed.md

@@ -0,0 +1,158 @@
+# Axis keys
+
+[Glyph index](index.md#glyph-reference)
+
+An array can have string keys on any of its axes. Keys name positions on that axis. Numeric coordinates remain 1-origin. Array operations retain their ordinary meaning.
+
+## Construction
+
+One string names the whole right value. Several strings name its leading-axis cells.
+
+```apl
+T←'price' 'qty':(1 2 3 ⋄ 4 5 6)
+≢T                          ⍝ 2x
+⍴('ab':11 12 13)            ⍝ ,1x
+'price' 'qty':2 3⍴⍳6       ⍝ ('price' 'qty':[1]2 3⍴⍳6)
+≢⍬:⍬                        ⍝ 0x
+```
+
+A character atom or vector is one string key. Use `,¨'ab'` for two one-character keys.
+
+```apl
+⍳[1]('a' 'b':1 2)           ⍝ ,⊂'ab'
+⍳[1]((,¨'ab'):1 2)          ⍝ ,¨'ab'
+```
+
+Several key vectors label successive axes. `[axes]` chooses which axes to label and always attaches to existing dimensions.
+
+```apl
+M←('alice' 'bob' ⋄ 'price' 'qty'):2 2⍴10 2 20 4
+⍴M                          ⍝ 2x 2x
+⍳[1]M                       ⍝ 'alice' 'bob'
+⍳[2]M                       ⍝ 'price' 'qty'
+:M                          ⍝ 2 2⍴10 2 20 4
+⍳[2](:[2]M)                 ⍝ 1x 2x
+```
+
+Monadic `:` removes axis keys. Inside dfns, group functional colon: `(X:Y)` or `(:Y)`. A direct colon separates a guard.
+
+Keys must be unique strings on each axis: DOMAIN. A key-list length must match its axis: LENGTH.
+
+## Selection and assignment
+
+A scalar selector removes its axis. A vector selector retains it. A character vector selects one string key.
+
+```apl
+M←('alice' 'bob' ⋄ 'price' 'qty'):2 2⍴10 2 20 4
+M['bob']                    ⍝ 'price' 'qty':20 4
+M[;'qty']                   ⍝ 'alice' 'bob':2 4
+M['alice';'qty']             ⍝ 2
+M[,⊂'alice']                ⍝ ('alice':[1]('price' 'qty':[2]1 2⍴10 2))
+('bob' 'qty')⊃M             ⍝ 4
+('bob' 'price')⌷M           ⍝ 20
+```
+
+Dot names are literal keys. `T.a.b` is `'b'⊃'a'⊃T`.
+
+```apl
+T←('n':1),('addr':'city':'Paris')
+T.addr.city                 ⍝ 'Paris'
+T.n+←1 ⋄ T.n                ⍝ 2
+```
+
+Plain named assignment appends missing rows or columns. New cells receive the array's prototype before assignment.
+
+```apl
+M←('alice' 'bob' ⋄ 'price' 'qty'):2 2⍴10 2 20 4
+M['cara']←30 5
+M['cara';'qty']              ⍝ 5
+M[;'tax']←1 2 3
+M['alice';'tax']             ⍝ 1
+```
+
+Missing keys on read or modified assignment: INDEX. Repeated selections on a keyed axis: DOMAIN. Numeric out-of-range assignment: INDEX.
+
+Scalar selection stores the whole RHS. A vector selection aligns its retained axis.
+
+```apl
+T←'aa' 'bb':1 2 ⋄ U←'bb' 'aa':8 9
+T['aa']←U ⋄ T['aa']         ⍝ 'bb' 'aa':8 9
+T[,⊂'aa']←U ⋄ T['aa']      ⍝ 9
+```
+
+## Agreement
+
+Corresponding keyed axes align by union: left keys, then right-only keys. An absent counterpart receives the present value's prototype.
+
+```apl
+('aa':2)+('bb':3)            ⍝ 'aa' 'bb':2 3
+('aa':2)×('bb':3)            ⍝ 'aa' 'bb':0 0
+('aa':0)=('bb':0)            ⍝ 'aa' 'bb':1x 1x
+```
+
+With one axis unkeyed, agreement is positional. Expanding a keyed singleton drops that axis's labels. Enclosure broadcasts within the named value.
+
+```apl
+('base':5)+10 20 30          ⍝ 15 25 35
+('base':5)+⊂10 20 30         ⍝ 'base':15 25 35
+```
+
+Explicit axes choose the correspondence.
+
+```apl
+M←('alice' 'bob' ⋄ 'price' 'qty'):2 2⍴10 2 20 4
+M+[2]('qty' 'tax':10 2)      ⍝ ('alice' 'bob' ⋄ 'price' 'qty' 'tax'):2 3⍴10 12 2 20 14 2
+```
+
+## Array operations
+
+Transpose moves axes with their labels. Reverse, rotate and filtering move labels with their positions. Reduction removes the reduced axis. Scan retains it. Shape-changing reshape drops keys.
+
+```apl
+M←('alice' 'bob' ⋄ 'price' 'qty'):2 2⍴10 2 20 4
++/M                         ⍝ 'alice' 'bob':12 24
++⌿M                         ⍝ 'price' 'qty':30 6
+4⍴'aa' 'bb':1 2             ⍝ 1 2 1 2
+```
+
+Rank preserves frame labels. Assembled cell axes keep labels shared by every result cell in the same order. Outer product retains both arguments' axes.
+
+Per-cell rotation drops labels on the rotated axis when its cells use different rotations. Other axes retain their labels.
+
+Inner product, Decode and matrix solve align keyed contracted axes by name. Key sets must match: LENGTH. With either axis unkeyed, contraction is positional.
+
+```apl
+('hi' 'lo':1 2)+.×('lo' 'hi':10 20) ⍝ 40
+```
+
+Catenate joins positions. Duplicate joined keys give DOMAIN. Replicate may filter a keyed axis, but repetition or padding on that axis gives DOMAIN.
+
+## Match and search
+
+Match aligns keys independently on every keyed axis. Shapes and unkeyed axes must match positionally. Searches compare values or cells. Found positions return axis keys.
+
+```apl
+V←'low' 'mid' 'high':10 20 30
+V≡⌽V                        ⍝ 1x
+V⍳20 99                     ⍝ ('mid' ⋄ 4x)
+V⍸5 15 25 40                ⍝ (0x ⋄ 'low' ⋄ 'mid' ⋄ 'high')
+⍒V                          ⍝ 'high' 'mid' 'low'
+('aa':7)∊('bb':7)            ⍝ 'aa':1x
+```
+
+Monadic Key passes named positions to its operand. Dyadic Key preserves labels on the grouped values.
+
+```apl
+V←'aa' 'bb' 'cc':1 2 1
+{⊂⍵}⌸V                     ⍝ (('aa' 'cc') ⋄ ,⊂'bb')
+```
+
+## Python and JSON
+
+Python dicts become keyed vectors recursively. `Array(data, axis_keys=[rows, cols])` attaches labels to existing axes. Use `None` for an unkeyed axis.
+
+`.axis_keys` returns a tuple of label tuples or `None`. `.np` copies values to an ndarray. `.py` returns a dict for a keyed vector and a pandas DataFrame for keyed arrays of rank ≥2.
+
+`.df` converts any rank to a DataFrame. The last axis supplies columns. Earlier axes supply rows, using a MultiIndex above rank 2. Unkeyed axes use 1-origin labels. Pandas is an optional, lazy dependency: `pip install 'basedpl[pandas]'`.
+
+The [process protocol](processes.md) adds `axis_keys`, e.g. `[null, ["price", "qty"]]`. All-unkeyed arrays omit it.

{basedpl-0.1.7 → basedpl-0.1.8}/docs/processes.md

@@ -19,7 +19,7 @@ The second response is:
 
 Use `json.dumps(code)` or `JSON.stringify(code)`, followed by a newline. Quotes are required; source newlines are escaped inside the string. Stdout contains only responses. The session remains usable after errors. EOF ends it.
 
-Atoms are encoded directly. Arrays carry shape, row-major data and prototype, including rank-zero arrays. Nested elements use the same encoding. A [keyed array](keyed.md) adds `keys`, a list of one string per element in row-major order.
+Atoms are encoded directly. Arrays carry shape, row-major data and prototype, including rank-zero arrays. Nested elements use the same encoding. A [keyed array](keyed.md) adds `axis_keys`: one string list or `null` per axis. All-unkeyed arrays omit it.
 
 | Element | JSON |
 |---|---|

{basedpl-0.1.7 → basedpl-0.1.8}/docs/python.md

@@ -38,6 +38,10 @@ Use `with Session() as apl:` or call `apl.close()` when finished. Returned array
 
 `Array` retains atoms, shape, nesting, numeric domain and empty prototypes. `.is_atom` distinguishes an atom from a rank-zero array; both have `.shape == ()`. `.apl` is APL display. `.py` converts atoms to Python values and character vectors to strings. Other arrays become NumPy arrays, including rank-zero arrays. `.np` always returns an ndarray.
 
+For [axis-keyed arrays](keyed.md), `.py` returns a dict at rank 1 and a pandas DataFrame at higher ranks. `.np` copies the values. Attach labels with `Array(data, axis_keys=[rows, cols])`; use `None` for an unkeyed axis. `.axis_keys` returns a tuple of label tuples or `None`.
+
+`.df` converts any array to a DataFrame. The last axis supplies columns; earlier axes supply rows, using a MultiIndex above rank 2. Unkeyed axes have 1-origin labels. Install `basedpl[pandas]` for this conversion. Pandas is imported on demand.
+
 ```python
 from fractions import Fraction
 from basedpl import Array

{basedpl-0.1.7 → basedpl-0.1.8}/pyproject.toml

@@ -17,7 +17,8 @@ classifiers = [
 ]
 
 [project.optional-dependencies]
-dev = ["fastship>=0.0.11", "maturin>=1.0,<2.0", "pytest", "numpy", "conkernelclient>=0.0.23"]
+pandas = ["pandas"]
+dev = ["fastship>=0.0.11", "maturin>=1.0,<2.0", "pytest", "numpy", "pandas", "conkernelclient>=0.0.23"]
 
 [project.scripts]
 bapl = "basedpl._cli:main"

{basedpl-0.1.7 → basedpl-0.1.8}/python/basedpl/__init__.py

@@ -24,10 +24,11 @@ def _value(raw, as_array=False, session=None):
         if not as_array: return result
         import numpy as np
         return np.array(result, dtype=_dtype([result]))
+    if not as_array and 'axis_keys' in raw and len(raw['shape']) > 1: return _dataframe(raw, session)
     shape, data = tuple(raw['shape']), [item(o) for o in raw['data']]
     items = raw['data'] or [raw['prototype']]
     nested = any(isinstance(o, dict) and 'shape' in o for o in items)
-    if not as_array and 'keys' in raw: return dict(zip(raw['keys'], data))
+    if not as_array and 'axis_keys' in raw: return dict(zip(raw['axis_keys'][0], data))
     if not as_array:
         if len(shape) == 1 and all(isinstance(o, str) for o in items): return ''.join(data)
     import numpy as np
@@ -37,6 +38,17 @@ def _value(raw, as_array=False, session=None):
     for i,o in enumerate(data): result[i] = o
     return result.reshape(shape)
 
+def _dataframe(raw, session=None):
+    try: import pandas as pd
+    except ImportError: raise ImportError('DataFrame conversion requires pandas: pip install "basedpl[pandas]"') from None
+    data = _value(raw, as_array=True, session=session)
+    shape = data.shape
+    keys = raw.get('axis_keys', [None] * len(shape))
+    labels = [list(range(1, n+1)) if k is None else k for n,k in zip(shape, keys)]
+    if len(shape) < 2: return pd.DataFrame(data.reshape(-1, 1), index=labels[0] if labels else [1], columns=[1])
+    index = labels[0] if len(shape) == 2 else pd.MultiIndex.from_product(labels[:-1])
+    return pd.DataFrame(data.reshape(math.prod(shape[:-1]), shape[-1]), index=index, columns=labels[-1])
+
 def _element(value, seen):
     np = sys.modules.get('numpy')
     if np is not None and isinstance(value, np.generic): value = value.item()
@@ -69,7 +81,7 @@ def _array(value, seen=None):
     if isinstance(value, dict):
         if not all(isinstance(k, str) for k in value): raise TypeError('keyed arrays need string keys')
         seen.add(id(value))
-        try: return _Array(dict(shape=[len(value)], data=[_element(o, seen) for o in value.values()], prototype=prototype, keys=list(value)))
+        try: return _Array(dict(shape=[len(value)], data=[_element(o, seen) for o in value.values()], prototype=prototype, axis_keys=[list(value)]))
         finally: seen.remove(id(value))
     if isinstance(value, str): return _Array(dict(shape=[len(value)], data=list(value), prototype=' '))
     if np is not None and isinstance(value, np.ndarray):
@@ -127,9 +139,9 @@ def _array_repr(raw):
     def cells(dims):
         if not dims: return item(next(data))
         return '[' + ', '.join(cells(dims[1:]) for _ in range(dims[0])) + ']'
-    if 'keys' in raw:
-        entries = '{' + ', '.join(f'{k!r}: {item(o)}' for k,o in zip(raw['keys'], raw['data'])) + '}'
-        return entries if len(shape) == 1 else f'Array({entries}, shape={tuple(shape)})'
+    if 'axis_keys' in raw:
+        if len(shape) == 1: return '{' + ', '.join(f'{k!r}: {item(o)}' for k,o in zip(raw['axis_keys'][0], raw['data'])) + '}'
+        return f'Array({cells(shape)}, axis_keys={raw["axis_keys"]!r})'
     if math.prod(shape) == 0: return f'Array([], shape={tuple(shape)})'
     return cells(shape)
 
@@ -157,18 +169,23 @@ def _context(*values):
 class Array(_Operators):
     "An immutable native APL value. Conversion to Python or NumPy makes a copy."
     __slots__ = ('_inner', '_session')
-    def __init__(self, value):
+    def __init__(self, value, *, axis_keys=None):
         self._inner = _array(value)
+        if axis_keys is not None: self._inner = self._inner.with_axis_keys(axis_keys)
         self._session = _context(value) if self._inner.needs_session else None
     @property
     def shape(self): return tuple(self._inner.shape)
     @property
+    def axis_keys(self): return tuple(None if k is None else tuple(k) for k in self._inner.axis_keys)
+    @property
     def is_atom(self): return self._inner.is_atom
     @property
     def py(self): return _value(self._inner.parts(), session=self._session)
     @property
     def np(self): return _value(self._inner.parts(), as_array=True, session=self._session)
     @property
+    def df(self): return _dataframe(self._inner.parts(), self._session)
+    @property
     def apl(self): return repr(self._inner)
     def _scalar(self): return _value(self._inner.scalar(), session=self._session)
     def __float__(self): return float(self._scalar())

{basedpl-0.1.7 → basedpl-0.1.8}/python/basedpl/apltests.py

@@ -211,6 +211,7 @@ def description(row):
 def convert(row):
     "Convert a prepared reference record without evaluating its program or changing its status."
     if error := row.get('expected_error'): expect = '⍝ error: '+error
+    elif 'expected_code' in row: expect = row['expected_code']
     elif 'expected' in row: expect = literal(row['expected'])
     else: raise ValueError(f"{row['id']}: missing independent expectation")
     return Case(row['code'], expect, row['id'], description(row), row.get('relative_tolerance', 0), row.get('absolute_tolerance', 0))
@@ -281,7 +282,7 @@ def add(ids, output='tests/reference', directory='tests/reference/inventory'):
         case = convert(row)
         result = json.loads(_check_reference(json.dumps(row), 2))
         if result['status']!='pass': raise ValueError(f'{id}: {result}')
-        if not row.get('expected_error'):
+        if not row.get('expected_error') and 'expected' in row and 'expected_code' not in row:
             result = json.loads(_check_reference(json.dumps(dict(code=case.expect, expected=row['expected'])), 2))
             if result['status']!='pass': raise ValueError(f'{id}: converted expectation: {result}')
         pending[id.split(':')[0].split('/')[0]].append(case)

{basedpl-0.1.7 → basedpl-0.1.8}/python/basedpl/reference.py

@@ -382,7 +382,7 @@ def scan(directory='tests/reference/inventory', source='', match='', timeout=.25
                 if case['status'] != 'pending':
                     inventory[case['status']] += 1
                     continue
-                if 'expected' not in case and not case.get('expected_error'):
+                if 'expected' not in case and not case.get('expected_code') and not case.get('expected_error'):
                     inventory['needs expectation'] += 1
                     continue
                 clean = re.sub(r"'(?:''|[^'])*'|⍝[^\n]*", '', case['code'])

basedpl-0.1.8/src/agreement.rs

@@ -0,0 +1,109 @@
+use crate::{
+    array::{generated_len, Layout},
+    keyed::Keys,
+    ErrorKind, Value,
+};
+
+pub(crate) enum Mapping {
+    Scalar,
+    Linear(usize),
+    Positions(Vec<usize>),
+    Axes(Vec<(usize, usize, usize)>),
+    Keyed(Vec<(usize, usize, Vec<Option<usize>>)>),
+}
+impl Mapping {
+    pub fn index(&self, i: usize) -> usize { self.get(i).expect("positional mapping") }
+    pub fn numeric<T: Copy + Default>(&self, data: &[T], i: usize) -> T { self.get(i).map_or_else(T::default, |j| data[j]) }
+    pub fn get(&self, i: usize) -> Option<usize> {
+        Some(match self {
+            Self::Scalar => 0,
+            Self::Linear(repeat) => i / repeat,
+            Self::Positions(positions) => positions[i],
+            Self::Axes(axes) => axes.iter().map(|&(stride, len, source)| i / stride % len * source).sum(),
+            Self::Keyed(axes) => axes.iter().try_fold(0, |n, (stride, source, map)| Some(n + map[i / stride % map.len()]? * source))?,
+        })
+    }
+    pub fn contract(left: &Layout, laxis: usize, right: &Layout, raxis: usize) -> Result<Self, ErrorKind> {
+        match (left.keys(laxis), right.keys(raxis)) { (Some(x), Some(y)) if x != y => Ok(Self::Positions(y.positions(x, false)?)), _ => Ok(Self::Linear(1)) }
+    }
+    fn new(input: &Layout, axes: &[usize], result: &Layout, count: usize) -> Self {
+        if count == 0 { return Self::Scalar; }
+        let (shape, output) = (input.shape(), result.shape());
+        let mut strides = vec![1; output.len()];
+        for i in (1..output.len()).rev() { strides[i - 1] = strides[i] * output[i]; }
+        if axes.iter().enumerate().any(|(a, &b)| input.keys(a).is_some() && input.keys(a) != result.keys(b)) {
+            let mut source = 1;
+            let mut map = Vec::new();
+            for (a, (&len, &b)) in shape.iter().zip(axes).enumerate().rev() {
+                let positions = (0..output[b])
+                    .map(|i| match (input.keys(a), result.keys(b)) {
+                        (Some(src), Some(dst)) => src.position(&dst.names()[i]),
+                        _ => Some(if len == 1 { 0 } else { i }),
+                    })
+                    .collect();
+                map.push((strides[b], source, positions));
+                source *= len;
+            }
+            return Self::Keyed(map);
+        }
+        let size: usize = shape.iter().product();
+        if size == 1 { return Self::Scalar; }
+        let mut source = 1;
+        let mut map = Vec::new();
+        for (&len, &axis) in shape.iter().zip(axes).rev() {
+            if len != 1 { map.push((strides[axis], len, source)); }
+            source *= len;
+        }
+        let repeat = count / size;
+        if map.iter().all(|&(stride, _, source)| stride == source * repeat) { Self::Linear(repeat) } else { Self::Axes(map) }
+    }
+}
+
+pub(crate) struct Agreement {
+    pub layout: Layout,
+    pub len: usize,
+    pub left: Mapping,
+    pub right: Mapping,
+}
+impl Agreement {
+    pub fn new(left: &Layout, right: &Layout) -> Result<Self, ErrorKind> {
+        Self::mapped(left, right, &(0..left.shape().len()).collect::<Vec<_>>(), &(0..right.shape().len()).collect::<Vec<_>>())
+    }
+    pub fn with_axes(left: &Layout, right: &Layout, axes: &[usize]) -> Result<Self, ErrorKind> {
+        if left.shape().len() < right.shape().len() { Self::mapped(left, right, axes, &(0..right.shape().len()).collect::<Vec<_>>()) } else { Self::mapped(left, right, &(0..left.shape().len()).collect::<Vec<_>>(), axes) }
+    }
+    fn mapped(left: &Layout, right: &Layout, xa: &[usize], ya: &[usize]) -> Result<Self, ErrorKind> {
+        let mut shape = vec![1; left.shape().len().max(right.shape().len())];
+        let mut keys = vec![None; shape.len()];
+        for axis in 0..shape.len() {
+            let (x, y) = (xa.iter().position(|&a| a == axis), ya.iter().position(|&a| a == axis));
+            let (nx, ny) = (x.map_or(1, |a| left.shape()[a]), y.map_or(1, |a| right.shape()[a]));
+            let (kx, ky) = (x.and_then(|a| left.keys(a)), y.and_then(|a| right.keys(a)));
+            if let (Some(x), Some(y)) = (kx, ky) {
+                let key = if x == y { x.clone() } else { Keys::new(x.names().iter().chain(y.names().iter().filter(|k| x.position(k).is_none())).cloned().collect())? };
+                shape[axis] = key.names().len();
+                keys[axis] = Some(key);
+            } else {
+                let n = if nx == ny || ny == 1 { nx } else if nx == 1 { ny } else { return Err(ErrorKind::Length); };
+                shape[axis] = n;
+                keys[axis] = kx.filter(|_| nx == n).or(ky.filter(|_| ny == n)).cloned();
+            }
+        }
+        let len = generated_len(&shape)?;
+        let layout = Layout::from(shape).with_keys(keys)?;
+        let x = Mapping::new(left, xa, &layout, len);
+        let y = Mapping::new(right, ya, &layout, len);
+        Ok(Self { layout, len, left: x, right: y })
+    }
+    pub fn values(&self, left: Option<&Value>, right: &Value, i: usize) -> (Option<Value>, Value) {
+        if self.len == 0 {
+            let item = |a: &Value| if a.is_empty() { a.prototype() } else { a.at(0) };
+            return (left.map(item), item(right));
+        }
+        let x = left.and_then(|a| self.left.get(i).map(|j| a.at(j)));
+        let y = self.right.get(i).map(|j| right.at(j));
+        let xf = left.map(|a| x.clone().unwrap_or_else(|| y.as_ref().map_or_else(|| a.prototype(), Value::fill)));
+        let yf = y.unwrap_or_else(|| x.as_ref().map_or_else(|| right.prototype(), Value::fill));
+        (xf, yf)
+    }
+}