basedpl 0.1.45__tar.gz → 0.1.46__tar.gz

{basedpl-0.1.45 → basedpl-0.1.46}/Cargo.lock

@@ -93,7 +93,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -139,7 +139,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -153,7 +153,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "basedpl",
  "bytemuck",
@@ -168,7 +168,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -1398,9 +1398,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c4b9032437f945f3db8fa14a4382bec40d21cb4edf1adb8711af6c43b1bb4c5"
+checksum = "b46e74f7d197774cef564fcf8f4f73984857abbf67c406b09d199f130821a642"
 dependencies = [
  "half",
  "hashbrown 0.17.1",
@@ -2052,7 +2052,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.45"
+version = "0.1.46"
 dependencies = [
  "anyhow",
  "serde_json",

{basedpl-0.1.45 → basedpl-0.1.46}/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["py"]
 
 [workspace.package]
-version = "0.1.45"
+version = "0.1.46"
 edition = "2021"
 rust-version = "1.98"
 license = "Apache-2.0"
@@ -51,7 +51,7 @@ num-complex = { version = ">=0.4.6, <1", features = ["bytemuck"] }
 num-bigint = ">=0.4.6, <0.5"
 num-traits = ">=0.2.19, <1"
 half = { version = ">=2.7.1, <3", features = ["num-traits", "bytemuck"] }
-rustymath = ">=0.1.14, <1"
+rustymath = ">=0.1.15, <1"
 strength_reduce = ">=0.2.4, <1"
 rand = ">=0.10.2, <1"
 # AnswerDotAI's fork measures text with a canvas, which works in a Web Worker: plotters-rs/plotters#746.

{basedpl-0.1.45 → basedpl-0.1.46}/DEV.md

@@ -2,7 +2,7 @@
 
 Keep the language concise to write, simple to read and consistent to understand. A design rule is a plan on trial. Discuss it when applying it makes a useful expression harder to read, removes something expressible or requires another special case. APL familiarity and compatibility are not costs in that decision. Change callers with an API change instead of adding compatibility layers.
 
-Speed and simplicity come before edge cases no real user meets. Follow IEEE, Rust and CPU behaviour where it gives a reasonable result. Don't add precision, sign normalization or defensive passes without an agreed need.
+Speed and simplicity come before edge cases no real user meets. Follow IEEE, Rust and CPU behaviour where it gives a reasonable result. The last bits of a result can differ between thread counts, platforms, builds and runs. Never spend speed, memory or code to make them agree. Don't add precision, sign normalization or defensive passes without an agreed need.
 
 ## You MUST read this ENTIRE section in FULL first
 
@@ -20,9 +20,9 @@ Build nothing else without discussion: no scratch crates, alternate target direc
 
 An already-running Python process retains its loaded extension. In a kernel, use `from basedpl.worker import fresh; fresh(code)` to check the installed `bpl` in a fresh worker instead of restarting the kernel. A BPL error raises `BplError`. Check one expression and read its result before building on it. `basedpl.bpltests.check_file` and `check_page` check reference files and documentation through the worker without building Rust.
 
-Measure with `BASEDPL_COSTS=1 cargo test --test speed -- --nocapture` or `basedpl.bpltests.time_cases(cases)`. Both use copies of the same data as the unit. Budgets are single-thread measurements. Use `time_cases(..., threads=...)` separately for scaling. `speed_costs()` reads the cases in `tests/speed.txt`; `cases=` selects expressions and `wasm=DIR` selects a browser build. `logged_costs(log)` reads CI output, and `cargo_costs(path)` runs either project's speed test. `set_budgets(native, wasm, run)` applies the rule in the budget file; `path=` selects rustymath's `tests/speed.txt`. The manual `Speed` workflow measures the native and wasm builds on CI.
+Measure with `BASEDPL_COSTS=1 cargo test --test speed -- --nocapture` or `basedpl.bpltests.time_cases(cases)`. Both use copies of the same data as the unit. Budgets are single-thread measurements. Use `time_cases(..., threads=...)` separately for scaling. `speed_costs()` reads the cases in `tests/speed.txt`; `cases=` selects expressions and `wasm=DIR` selects a browser build. `logged_costs(log)` reads CI output, and `cargo_costs(path)` runs either project's speed test. `set_budgets(native, wasm, run)` applies the rule in the budget file; `path=` selects rustymath's `tests/speed.txt`. The manual `Speed` workflow measures the native and wasm builds on CI. To compare a change with the build before it, copy the installed `bpl` before the change, then time both copies in turn through `basedpl.worker.Worker(command=(path, '--worker'))` with the `costs` request that `speed_costs` sends. Don't restore old code in the shared tree to get a baseline.
 
-Cooperating tools share `/tmp/aai-ws-timing.lock`. Timings take it exclusively. `cargo develop`, `cargo wasm`, the reference test and pytest take it shared. Other Rust tests and bare Cargo commands do not all take it. After five minutes a timing fails; a build/test proceeds without the lock. Never hold it in the shared kernel process or coordinate timings manually. A timing launched there would block behind the hold and stall other agents' kernel calls. Native timings set rustymath's current-thread count to one and request user-interactive macOS QoS to favour performance cores. QoS is not CPU affinity.
+Cooperating tools share `/tmp/aai-ws-timing.lock`. Timings take it exclusively. `cargo develop`, `cargo wasm`, the reference test and pytest take it shared. Other Rust tests and bare Cargo commands do not all take it. After five minutes a timing fails; a build/test proceeds without the lock. After 30 seconds, an exclusive wait prints the processes with the lock file open. The list can include processes that are only waiting for the lock. Never hold it in the shared kernel process or coordinate timings manually. A timing launched there would block behind the hold and stall other agents' kernel calls. Native timings set rustymath's current-thread count to one and request user-interactive macOS QoS to favour performance cores. QoS is not CPU affinity.
 
 Run `cargo wasm` during development only for browser work. Agents use `cargo wasm --out DIR` and set `BASEDPL_WASM=DIR` when running `node --test tests/wasm.mjs` and `node --no-liftoff --test tests/wasm-speed.mjs`. This avoids replacing a module another agent is using. For other edits under `cfg(web)` or `host_web.rs`, check compilation with `cargo check -p basedpl --target wasm32-unknown-unknown`.
 
@@ -66,7 +66,7 @@ LTO-off incremental builds keep an edit from recompiling every caller that inlin
 
 Generic loop instances can concentrate in the defining module's codegen unit. Mark loop helpers `#[inline]` when their instances need to compile with the caller's kernel table, including nested helpers. Kernel tables have separate modules: `booleans`, `wholes`, `float_arithmetic`, `float_kernels` and `complex_kernels`. `at_widths!` gives the concrete widths their own modules. Keep new tables separate and add kernel specializations only for measured gains.
 
-Use `cargo build --lib --bins --profile test --timings` to inspect the normal build. Its report under `target/cargo-timings/` separates frontend and codegen time. `BASEDPL_UNITS=1 cargo test --test units -- --nocapture` lists large units and their functions. `BASEDPL_SIZES=pattern cargo test --test units -- --nocapture` measures machine code matching a demangled-name regex. These commands diagnose the current compilation arrangement; don't create scratch builds to approximate it.
+Use `cargo build --lib --bins --profile test --timings` to inspect the normal build. Its report under `target/cargo-timings/` separates frontend and codegen time. `BASEDPL_UNITS=1 cargo test --test units -- --nocapture` lists large units and their functions. `BASEDPL_SIZES=pattern cargo test --test units -- --nocapture` measures machine code matching a demangled-name regex. `BASEDPL_SIZES` sees only basedpl's own codegen units. `BASEDPL_SIZES_DIFF=old:new cargo test --test units machine_code_growth -- --nocapture` compares two binaries, such as copies of `bpl` from before and after a change, by generic function across every crate. These commands diagnose the current compilation arrangement; don't create scratch builds to approximate it.
 
 ## Code map
 
@@ -107,7 +107,7 @@ Tail calls reuse frames while preserving lexical dependencies. Handlers disable
 
 ## Values, layouts and assignment
 
-`Value` holds a number, character, function, operator or shared array. Compact storage holds Booleans, narrow integers, width-specific floats/complex numbers or characters. Mixed storage holds `Value`s and memoizes its prototype and innermost lexical dependency. Other properties are computed when needed. A layout and its shared `Arc<Storage>` can be copied separately; changing axes need not copy items. `Buffer`, `Value::buffer` and `from_buffer` are the public width-preserving frontend boundary.
+`Value` holds a number, character, function, operator or shared array. Compact storage holds Booleans, narrow integers, width-specific floats/complex numbers or characters. Mixed storage holds `Value`s and memoizes its prototype and innermost lexical dependency. Other properties are computed when needed. An array holds its layout and its storage in one allocation. Its `Shape` holds ranks 0 to 2 inline, so a small array allocates no shape. Constructors take `impl Into<Shape>`: pass a slice, or an array such as `[n]`, rather than building a `Vec`. A shape, key or name change on a shared array makes a view of the base array's storage and copies no items. `Buffer`, `Value::buffer` and `from_buffer` are the public width-preserving frontend boundary.
 
 Atoms, rank-0 arrays and singleton vectors are distinct. Function nodes retain handles, not lexical frames or Python objects. Functions match by their parts; dfns and generators match by identity. Operators can be values and can cross the native Python boundary. Values and function nodes are `Send + Sync`.
 
@@ -141,7 +141,7 @@ Floats use IEEE NaN, infinity and signed zero. Comparison treats NaN as unequal;
 
 Only f64 comparisons use the session tolerance, from 0 to `1E-14`. f32/f16 compare exactly except fixed-point convergence, which uses four ulps; f64 convergence uses `1E-14` independently of the preference. Index/count/Boolean/character-offset conversion uses `near_integer` with the fixed default tolerance, not the comparison preference. The tolerant types and objects come from rustymath. Keep independent inside/outside-tolerance tests with exact/mixed controls; don't use language comparison as its own oracle.
 
-`search.rs` selects compact exact or tolerant backends. Exact integer/Boolean/character storage uses keys; float searches use their width. Integer haystacks accept the whole-number shortcut only for exactly whole float needles. Tolerant indexing validates whole-key matches unless the haystack is exactly whole and falls back to buckets on mismatch. Classification intentionally chains tolerance through sorted runs, so it need not match every member to one representative. Other cells use exact hashes or first-number buckets with `Value::matches` confirmation, falling back to pairwise comparison where indexing is unsuitable. Grade is stable. Position buffers use u32 and become integer storage without another pass.
+`search.rs` selects compact exact or tolerant backends. Exact integer/Boolean/character storage uses keys; float searches use their width. Integer haystacks accept the whole-number shortcut only for exactly whole float needles. Tolerant indexing validates whole-key matches unless the haystack is exactly whole and falls back to buckets on mismatch. Classification intentionally chains tolerance through sorted runs, so it need not match every member to one representative. Other cells use exact hashes or first-number buckets with `Value::matches` confirmation, falling back to pairwise comparison where indexing is unsuitable. Grade is stable. Position buffers use u32 and become integer storage without another pass. `⍷` and monadic Key take each class's positions from `search::class_positions`, which keeps a class's own buffer for 32-bit positions and copies narrower ones once from the shared buffer. Dyadic Key selects rows through `Grouped::each` slices. Key with the operand `≢⊢`, which `≢∘⊢` also builds, counts its classes through `search::class_counts` and builds no positions.
 
 `Domain` and `with_field!` select working reals, Complex64 or BigRational for generic numeric algorithms. Compact storage selects the domain without scanning its items. `number::read` converts once; `Field::array` builds compact float/complex results without a `Number` per item. Each caller lists the domains it supports. Compact complex input does not take a real path merely because all imaginary parts are zero; results built through `Value::complex` can normalize to float storage.
 
@@ -165,7 +165,7 @@ A failed compact kernel leaves placeholder results and triggers a wider/exact/co
 
 Folds by algebraic float operations can regroup. Contiguous subtraction/division folds use `Alternating`; quotients fall back to item-by-item folding if their products leave the normal range. Boolean scans compose truth-table maps; comparison scans compute both possible totals in bulk and use `reduce::chosen`. Seeds, axis lanes and scalar fallback preserve the language's accumulation direction. Generic reductions stay right-associated and preserve operand call order/effects. Monadic `f.g` is the exception: it memoizes each minor's expansion, and a cached minor does not repeat operand calls or their effects. Determinant/permanent fast paths use the appropriate rustymath backend.
 
-The automatic Rayon scheduler currently serves rustymath elementwise `many` and `pairs`, not general matrix products, factorizations or reduction loops. It adapts to call cost, uses `RAYON_NUM_THREADS` by default and accepts current-thread overrides through `parallel::set_threads` (0 default, 1 serial). Nested Rayon work does not split again; wasm is serial. Small converted chunks and fusion's serial outer traversal limit the work available to it. Don't infer multicore execution from a large array alone.
+The automatic Rayon scheduler serves rustymath elementwise `many` and `pairs`, folds through `reduce::along`, fused chains and matrix products. Scans don't split. Decompositions split in the products of their blocked updates, the passes of their Hermitian and bidiagonal reductions, and their divide-and-conquer merges. `rank` sends dyadic `+.×` and `⌹`, monadic `⌹` and `-.×`, and `•decompose` over the 2-cells of an unkeyed stack with compact storage to `primitive::stacked` and `stacked_decompositions`. They run each cell through the rustymath function it uses alone. Rustymath's `parallel::stack_with` splits whole cells across threads in rounds, with `check_now` between rounds. A caller whose checks run far apart, such as a round or a rustymath `_with` callback, calls `check_now`, because `Context::check` reads the clock only on every 64th call. The scheduler adapts to call cost, uses `RAYON_NUM_THREADS` by default and accepts current-thread overrides through `parallel::set_threads` (0 default, 1 serial). `Session::evaluation` applies a session's `•prefs ["threads":n]` to each of its evaluations, then restores the thread's own setting. A session that never sets it keeps the evaluating thread's setting, such as the timing harness's one thread. Nested Rayon work does not split again; wasm is serial. A fused chain splits in pieces of whole blocks: an elementwise chain through `parallel::extended`, and a folded one through `reduce::fold_pieces`. On one thread an elementwise chain appends straight to its result, because copying each block into a piece's slots cost up to 1.2 copies there. Small converted chunks limit the work available to the scheduler. Don't infer multicore execution from a large array alone.
 
 Packed numeric, Boolean and equality-count inner products use `rustymath::linalg`. Integer calls use `Inner::checked` before relying on an exact compact result. Structural gather/compress and interval index also reuse rustymath. Measure generic/backend changes in both projects; callers' codegen and layout determine costs that isolated kernels miss.
 
@@ -201,7 +201,7 @@ The Jupyter adapter in `cli/src/kernel.rs` uses kernmini and a `ThreadWorker`. I
 
 ### Browser
 
-`cargo wasm` builds an incremental release-profile npm package with wasm-bindgen glue, language/input assets, grammar and canvas support. `--out DIR` leaves the docs' local playground assets alone; `--strip` removes function-name metadata for distribution. Keep wasm-bindgen glue and crate versions aligned through the workspace lock. Avoid fat LTO here because rebuild cost and enlarged stack frames conflict with browser development and recursion limits.
+`cargo wasm` builds an incremental release-profile npm package with wasm-bindgen glue, language/input assets, grammar and canvas support. `--out DIR` leaves the docs' local playground assets alone; `--strip` removes function-name metadata for distribution. Keep wasm-bindgen glue and crate versions aligned through the workspace lock. Avoid fat LTO here because rebuild cost and enlarged stack frames conflict with browser development and recursion limits. `wasm-objdump -h DIR/basedpl_wasm_bg.wasm` lists the module's section sizes, including `name`. `twiggy diff` matches functions by full name, including crate hashes that change between builds. To compare two builds by function, compare their `twiggy top -n 1000000 -f json` listings with the hashes removed.
 
 Browser `Session.run` streams MIME events and returns a protocol error or null. `eval` transfers values through `js.rs` but discards output and cannot export BPL functions/operators; `bind` imports page values/functions. Typed arrays transfer without another page-worker copy. JavaScript functions live in a thread-local registry and core function nodes hold slots, preserving Send/Sync values. `host_web.rs` implements the browser's clock, synchronous I/O/fetch and RegExp behaviour. File/URL reads resolve against the configured base. Unsupported native filesystem/locale operations stay unavailable; browser `•nput` writes only stdout and `•js` is browser-only.
 

{basedpl-0.1.45 → basedpl-0.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedpl
-Version: 0.1.45
+Version: 0.1.46
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore

{basedpl-0.1.45 → basedpl-0.1.46}/lib/array.bpl

@@ -270,7 +270,7 @@ in ← {  ⍝ Locations of item ⍺ in array ⍵.
   ⍬{  ⍝ ⍺ is pick-path
     item≡⍵?,⊂⍺;  ⍝ match: path
     D≥≡⍵?⍬;  ⍝ give up
-    paths←(⍺↣,⊂)¨⍳⍴⍵  ⍝ extended paths
+    paths←⍺↣,⊂ ¨⍳⍴⍵  ⍝ extended paths
     ,/, paths ∇¨ ⍵
   }⍵  ⍝ ⍵ is searched-in array
 }
@@ -439,5 +439,5 @@ subs ← {  ⍝ Vector substitution.
 ⍝ From http://dfns.dyalog.com/c_lcase.htm and http://dfns.dyalog.com/c_ucase.htm
 letters ← ["abcdefghijklmnopqrstuvwxyzåäöàæéñøü" "ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖÀÆÉÑØÜ"]  ⍝ Lower and upper case, at matching positions.
 recase ← {[from to]←⍺ ⋄ [(from,,⍵)⍳⍵]⌷to,,⍵}  ⍝ Simple array ⍵, with each letter from ⍺'s first list replaced by its second.
-lcase ← (⌽letters)↣recase  ⍝ Lower-casification.
+lcase ← ⌽letters ↣recase  ⍝ Lower-casification.
 ucase ← letters↣recase  ⍝ Upper-casification.

{basedpl-0.1.45 → basedpl-0.1.46}/lib/dyalog.bpl

@@ -16,7 +16,7 @@ life←{[1 ⍵]∨.∧3 4=¨⊂+/,¯1 0 1⊖⊗¯1 0 1⌽⊗⊂⍵}
 ⍝ From https://dfns.dyalog.com/c_rmcm.htm
 rmcm←{  ⍝ Replace comments with blanks.
   cm←∨\(⍵='⍝')>≠\⍵='''
-  ' '@(⍸cm) ⍵
+  ' '@ ⍸cm ⍵
 }
 
 ⍝ From https://dfns.dyalog.com/c_ripple.htm
@@ -141,7 +141,7 @@ dots←{  ⍝ Show indentation with white dots.
   spcs←∧\' '=⍵
   xdents←ends∧1,0 ¯1↓spcs
   flood←(⍪1 2){hits←⍺⍷⍵ ⋄ ~1∊,hits?⍵;⍺ ∇ hits+⍵}spcs+⊽xdents
-  ⍺@(⍸2=flood-xdents) ⍵
+  ⍺@ ⍸2=flood-xdents ⍵
 }
 
 ⍝ From https://dfns.dyalog.com/c_logic.htm
@@ -363,7 +363,7 @@ baby←{  ⍝ Manchester Small Scale Experimental Machine.
   fetch←{,(yshift ⍵)#⍺}
   store←{⍶@ 1⍳⍨yshift⍹ ⍵}
   decode←{(⍳≢⍵ ∊ 0 5 13 16)⊂⍵}
-  yshift←(0=⍳≢⍵)↣{~1∊⍵?⍺;(¯1⌽⍺) ∇ dec ⍵}
+  yshift←0=⍳≢⍵ ↣{~1∊⍵?⍺;(¯1⌽⍺) ∇ dec ⍵}
   addsub←{c←⍺ ⍶ ⍵ ⋄ ~1∊c?⍺ ⍹ ⍵;(⍺≠⍵) ∇ 0,¯1↓c}
   add←∧addsub∨
   sub←<addsub>
@@ -507,7 +507,7 @@ sudoku←{  ⍝ All solutions, with square or ⍺-shaped groups.
   inx←↓(,wid⊥¨grp↣ר⍳⌽grp)+⊗,wid⊥¨⍳grp
   inx,←{(↓⍵),↓⍵ᵀ}(⍴⍵)⍴⍳wid²
   bas←(≢,⍵)⍴⊂set
-  (,⍵)↣{q←[⍵]⌷⍺ ⋄ (q=0 # q)←⊂set~,/q ⋄ bas.[⍵]∩←,¨q}¨inx
+  ,⍵ ↣{q←[⍵]⌷⍺ ⋄ (q=0 # q)←⊂set~,/q ⋄ bas.[⍵]∩←,¨q}¨inx
   ∆sqz←{
     0=≢⍵?⍺;i←↑⍵ ⋄ q←⍺
     b←1<≢¨[i]⌷⍺ ⋄ ~∨/b?⍺ ∇ 1↓⍵;

{basedpl-0.1.45 → basedpl-0.1.46}/lib/graph.bpl

@@ -234,7 +234,7 @@ stpaths ← {  ⍝ Spanning tree paths.
     (⊂⍬)∧.≡next?⍺;  ⍝ all null: finished.
     exts←⊂¨⍵⊃¨⊂⍺ ,¨¨ next  ⍝ paths to next tree level.
     indx←,/next
-    paths←(,/exts)@indx ⍺
+    paths←,/exts @indx ⍺
     paths ∇ indx  ⍝ advance to next tree level.
   }root  ⍝ index of starting vertex.
 }
@@ -272,7 +272,7 @@ sudokuMatrix ← {  ⍝ Matrix for ⍵ ⍵-Sudoku puzzle.
   col←↓0 0 1 1 1 1 1 1 1 1#⍠¯1⊃z
   box←↓1 0 1 0 1 1 1 1 1 1#⍠¯1⊃z
   all←↓1 1 1 1 0 0 1 1 1 1#⍠¯1⊃z
-  same←≡/∘(1 0 0 0 1 0 0 0⊂)  ⍝ matching pairs.
+  same←≡/∘ 1 0 0 0 1 0 0 0⊂  ⍝ matching pairs.
   same¨row,col,box,all  ⍝ constraints matrix for ⍵ ⍵-puzzle.
 }
 

{basedpl-0.1.45 → basedpl-0.1.46}/lib/numeric.bpl

@@ -277,7 +277,7 @@ kcell ← {  ⍝ Relationship between point and k-cell.
   ⍺←(≢⍵)#⍠¯1 [2 1]⍴0 1  ⍝ Default is unit k-cell.
   b←,⍠(2=⍴⍴⍺ # 0)⍺
   p←(2⌊⍴⍴⍺ ↓ 1 1,⍴⍵)⍴⍵  ⍝ Points to evaluate.
-  d←(,⍶⌿)⍤1 ⍉×-b,.-p
+  d←,⍶⌿ ⍤1 ⍉×-b,.-p
   ⍶/⍬?⌈/d;5⊥d
 }
 

{basedpl-0.1.45 → basedpl-0.1.46}/lib/tree.bpl

@@ -486,7 +486,7 @@ tfmt ← {  ⍝ Char matrix from tree.
   ⍺←""  ⍝ default: no indentation.
   1=≡,⍵?⊃,↓⍺,⍵;
   node←⍺,↑⍵
-  subs←(⍺,4↑'·')↣∇¨1↓⍵  ⍝ subtrees.
+  subs←⍺,4↑'·' ↣∇¨1↓⍵  ⍝ subtrees.
   ⊃(⊂node),,/↓¨subs
 }
 
@@ -496,7 +496,7 @@ tnest ← {  ⍝ Array from TreeView style tree.
   [dvec ivec]←⍵  ⍝ depth and items vectors.
   1=≢dvec?↑ivec;
   node←1↑ivec  ⍝ tree: node value.
-  [dsub isub]←(1=dvec)↣⊂¨⍵  ⍝ sub treeviews.
+  [dsub isub]←1=dvec ↣⊂¨⍵  ⍝ sub treeviews.
   node,∇¨↓⍉[≤dsub⋄isub]
 }
 

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/arrays.ipynb

@@ -712,7 +712,7 @@
     }
    ],
    "source": [
-    "(≥⍳)⍤0 [2 4]"
+    "≥⍳ ⍤0 [2 4]"
    ]
   },
   {
@@ -740,7 +740,7 @@
     }
    ],
    "source": [
-    "(≥⍳)¨[2 4]"
+    "≥⍳ ¨[2 4]"
    ]
   },
   {

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/comparison.qmd

@@ -383,7 +383,7 @@ The operand ends at the space. `1 2 3 4` is in brackets to keep it out of the op
 ```
 
 ```bpl
-(+/⊢)⌺3 [1 2 3 4]       ⍝ 3 6 9 7
++/⊢ ⌺3 [1 2 3 4]       ⍝ 3 6 9 7
 +/¯3↕1 2 3 4           ⍝ 3 6 9 7
 ```
 

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/evaluation.qmd

@@ -27,12 +27,13 @@ Operators bind before functions apply. An operator's left [operand](terms.qmd#te
 
 A numeric operand and numeric argument need an explicit separator. `f⍣¯25` has operand `¯25`, while `f⍣¯2 5` has operand `¯2 5`. Use `f⍣¯2(5)` or `f⍣¯2⊢5` to give operand `¯2` and argument `5`.
 
-Each run acts as a parenthesised group, which is one token, so an operator at the end of a run takes the next run as its right operand, as it takes a touching token. A name that holds a dyadic operator counts. In `⌊@ 10× x`, the right operand of `@` is the run `10×`.
+Each run counts as one token, as a parenthesised group does. An operator at the end of a run takes the next run as its right operand, as it takes a touching token: in `⌊@ 10× x`, the right operand of `@` is the run `10×`. An operator at the start of a run takes the previous run as its left operand: in `≢⊢ ⌸x`, the left operand of `⌸` is the run `≢⊢`. Names that hold operators count in both places.
 
 ```bpl
 m←2 3⍴⍳6 ⋄ +/⍤1 m               ⍝ 3 12
 m←2 3⍴⍳6 ⋄ +/⍤1m                ⍝ 3 12
 ⌊@ 10× 1.25 2.78                 ⍝ 1.2 2.7
+x←0 1 1 0 1 1 ⋄ ≢⊢ ⌸x            ⍝ [2 4]ₓ
 x←5 ⋄ ≥⍣3 x                     ⍝ 8
 ≥⍣3(5)                          ⍝ 8
 ≥⍣3⊢5                           ⍝ 8

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/gallery/phyllotaxis.bpl

@@ -8,6 +8,6 @@ z←50ⱼ50+1.8×(√i)×○i×golden
 size←0.4+1.1×t
 hue←300×t
 seed←{["cx":⍵₀;"cy":⍵₁;"r":⍵₂;"fill":"hsl(",(⍕⍵₃),",80%,60%)"] circle ""}
-seeds←(⊂seed)⍤1 (∨z),⍉[size⋄hue]
+seeds←⊂seed ⍤1 (∨z),⍉[size⋄hue]
 back←["width":100;"height":100;"fill":"#111"] rect ""
 ["width":500;"height":500] •svg [back],seeds

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/glyphs/ceiling.qmd

@@ -9,7 +9,7 @@ Keys: `Alt-s`. Ranks: `0` monadic, `0 0` dyadic
 ⌈3r2              ⍝ 2ₓ
 ```
 
-`X⌈Y` takes the real maximum. Pervasive. Beside NaN it gives NaN, as NumPy's `maximum` does. Empty reduction identity: `¯∞`.
+`X⌈Y` takes the real maximum. Pervasive. Beside NaN it gives `Y`'s item. Beside NaN, `⌈/` and `⌈\` give NaN or the greatest other item, depending on the processor. Empty reduction identity: `¯∞`.
 
 ```bpl
 3⌈1 5             ⍝ 3 5

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/glyphs/circle.qmd

@@ -29,9 +29,13 @@ Keys: `Alt-o`. Ranks: `0` monadic, `0 0` dyadic
 | 7 | tanh | arctanh |
 | 8 | `√(-1−y²)` | `-√(-1−y²)` |
 
-Uses complex continuation where needed.
+Uses complex continuation where needed. The cuts of `3○⁻¹` and `5○⁻¹` lie on the imaginary axis. As in C99 and NumPy, the sign of a zero real part chooses the side of these cuts: `3○⁻¹ 0j2` and `3○⁻¹ ¯0j2` give results on opposite sides. On a cut along the real axis, results always come from the side above the cut, because BPL turns a number whose imaginary part is zero, `¯0` included, into a real. For example, `2j¯0` is `2`. A real argument computes with an imaginary part of +0:
 
-APL difference: there are no negative codes or codes 9 to 12. Write `¯k○Y` as `k○⁻¹Y`. `∨Y` gives the real and imaginary parts, `|Y` the magnitude, and `∧Y` the magnitude and phase.
+```bpl
+1○⁻¹2              ⍝ 1.5707963267948966j1.3169578969248166
+```
+
+APL difference: there are no negative codes or codes 9 to 12. Write `¯k○Y` as `k○⁻¹Y`. `∨Y` gives the real and imaginary parts, `|Y` the magnitude, and `∧Y` the magnitude and phase. On a branch cut, APL takes the side below the cut for a positive real argument.
 
 ## Inverse
 

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/glyphs/floor.qmd

@@ -15,7 +15,7 @@ Complex floor uses APL's Gaussian-integer rule.
 ⌊1.5j0.5          ⍝ 1j1
 ```
 
-`X⌊Y` takes the real minimum. Pervasive. Beside NaN it gives NaN, as NumPy's `minimum` does. Empty reduction identity: `∞`.
+`X⌊Y` takes the real minimum. Pervasive. Beside NaN it gives `Y`'s item. Beside NaN, `⌊/` and `⌊\` give NaN or the least other item, depending on the processor. Empty reduction identity: `∞`.
 
 ```bpl
 3⌊1 5             ⍝ 1 3

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/glyphs/key.qmd

@@ -8,10 +8,10 @@ Keys: `Alt-q =`
 1 1 2{+/⍵}⌸10 20 30 ⍝ 30 30
 ```
 
-`f⌸Y` uses `Y` as keys and their positions as values.
+`f⌸Y` uses `Y` as keys and their positions as values. `≢⊢ ⌸Y` counts the items with each key, without building the groups.
 
 ```bpl
-{≢⍵}⌸"banana"       ⍝ [1 3 2]ₓ
+≢⊢ ⌸"banana"      ⍝ [1 3 2]ₓ
 ```
 
 Keys match with [tolerance](../evaluation.qmd#equality-and-ordering), as in `≠`. Results assemble with fill. Empty input calls `f` once for its prototype.

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/glyphs/stencil.qmd

@@ -7,13 +7,13 @@ Keys: `Alt-q Backtick`
 Negative sizes in [Windows](windows.qmd) return the same windows as one array.
 
 ```bpl
-(+/⊢)⌺3 [1 2 3 4]     ⍝ 3 6 9 7
++/⊢ ⌺3 [1 2 3 4]     ⍝ 3 6 9 7
 ```
 
 `⍵` is the window. `⍺` gives signed padding counts per axis: positive at the start, negative at the end. The two-chain `(+/⊢)` discards `⍺`. A two-row specification gives sizes then movements.
 
 ```bpl
-(+/⊢)⌺[[3]⋄[2]]⍳8  ⍝ 1 6 12 18
++/⊢ ⌺[[3]⋄[2]]⍳8  ⍝ 1 6 12 18
 ```
 
 Results assemble with fill.
@@ -21,7 +21,7 @@ Results assemble with fill.
 A function right operand computes the specification from the argument: `f⌺g Y` is `f⌺(g Y) Y`. [Rank](rank.qmd) and [Axis](axis.qmd) take a function right operand in the same way. Here the window size is the square root of the length, rounded up:
 
 ```bpl
-(+/⊢)⌺{⌈√≢⍵} ⍳9   ⍝ 1 3 6 9 12 15 18 21 15
++/⊢ ⌺{⌈√≢⍵} ⍳9   ⍝ 1 3 6 9 12 15 18 21 15
 ```
 
 ## Errors

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/keyed.ipynb

@@ -1906,7 +1906,7 @@
     }
    ],
    "source": [
-    "(+/⊢)⌺3 w\n",
+    "+/⊢ ⌺3 w\n",
     "{⍳⍠0⍵ ≡ \"aa\" \"bb\" \"cc\"}⌺3 w"
    ]
   },

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/llms.txt

@@ -50,7 +50,7 @@ Undo and Under follow BQN's inferred-properties spec. Inverse operations are wri
 
 ## Grouping, selection and keys
 
-Spaces group as if each unspaced run were parenthesised, after literal strands join: `a+b × c+d` is `(a+b)(×)(c+d)`, and `1 2+3` is `(1 2)+3`. Names don't join strands. A run ending in a function is an APL-style train: `+/÷≢ x` is mean, but `+/÷≢x` is not. A subject before a function binds the one part after it: `2×` doubles, `2|#⊢` is `(2|)#⊢`, `2+/` binds `+/`, and `2(+×-)` binds the whole train. An operator takes the whole function on its left and one token on its right, and a literal strand counts as one token. Each run acts as a parenthesised group, so an operator that ends a run takes the next run: in `⌊@ 10× x`, the operand is `10×`. Only spaces build strands: in `f⍣3'b'` and `f⍤1[2 3]`, the touching literal is the argument. Separate a numeric argument from a numeric operand with parentheses or `⊢`.
+Spaces group as if each unspaced run were parenthesised, after literal strands join: `a+b × c+d` is `(a+b)(×)(c+d)`, and `1 2+3` is `(1 2)+3`. Names don't join strands. A run ending in a function is an APL-style train: `+/÷≢ x` is mean, but `+/÷≢x` is not. A subject before a function binds the one part after it: `2×` doubles, `2|#⊢` is `(2|)#⊢`, `2+/` binds `+/`, and `2(+×-)` binds the whole train. An operator takes the whole function on its left and one token on its right, and a literal strand counts as one token. Each run acts as a parenthesised group, so an operator that ends a run takes the next run: in `⌊@ 10× x`, the operand is `10×`. An operator that starts a run takes the previous run as its left operand: `≢⊢ ⌸x` is `(≢⊢)⌸x`. Only spaces build strands: in `f⍣3'b'` and `f⍤1[2 3]`, the touching literal is the argument. Separate a numeric argument from a numeric operand with parentheses or `⊢`.
 
 Names use letters, `∆`, `⍙`; `_` escapes the next character (and following digits). `f2` calls `f`; `f_2` is a name. No BQN casing rules; names take their runtime value's role. Lone `_` discards an assignment.
 
@@ -81,7 +81,7 @@ Plain assignment is local; modified/selective updates change the nearest binding
 
 Use lowercase `j` in complex literals throughout tests and examples, including adapted reference cases. Reserve uppercase `J` for explicit input-alias tests. Keep archived upstream source unchanged. Write literal matrices in array notation, `[10 20 30⋄40 50 60]`, not as a reshape. Keep `⍴` where the example is about reshape. A `⋄` that separates rows has no spaces around it. A `⋄` that separates statements has a space on each side.
 
-Brackets are the usual way to write a list, and to build an array from names or expressions. A bare literal list, such as `1 2 3`, is a shorthand. Write a list of names in brackets, as in `[a b]`, even where `a b` would also work. Write `[n 2]⍴0`, `[x],y`, `[a⋄b]` and `f⍤1 m`, not APL's `(n,2)⍴0`, `(⊂x),y`, `⊃[a b]` and `⊃f¨↓m`. End an operand with a space where possible. After a dyadic operator and a space, the whole next run is the operand. For example, `⌊@ 10× x` needs no parentheses. Where a literal operand would run into the argument, a vector argument goes in touching brackets: `f⍤1[2 3]`. For a simple numeric argument, `f⍣¯2⊢5` can read more clearly than `f⍣¯2(5)`. Keep parentheses when they clarify grouping. Judge each line by how it reads. Report any case where none of these forms works.
+Brackets are the usual way to write a list, and to build an array from names or expressions. A bare literal list, such as `1 2 3`, is a shorthand. Write a list of names in brackets, as in `[a b]`, even where `a b` would also work. Write `[n 2]⍴0`, `[x],y`, `[a⋄b]` and `f⍤1 m`, not APL's `(n,2)⍴0`, `(⊂x),y`, `⊃[a b]` and `⊃f¨↓m`. End an operand with a space where possible. After a dyadic operator and a space, the whole next run is the operand. For example, `⌊@ 10× x` and `≢⊢ ⌸x` need no parentheses. When both operands of a dyadic operator are compound, keep both in parentheses, as in `(•ucs 9)@(⍸tabs) ⍵`. An operand keeps its parentheses when a left argument comes before it, as in `tree (⍺⍢)/ next`. Where a literal operand would run into the argument, a vector argument goes in touching brackets: `f⍤1[2 3]`. For a simple numeric argument, `f⍣¯2⊢5` can read more clearly than `f⍣¯2(5)`. Keep parentheses when they clarify grouping. Judge each line by how it reads. Report any case where none of these forms works.
 
 A name applied to a literal touches it, as a glyph does: `fib10` and `1+⌽f5`. Write it that way where it's shorter and needs no new parentheses. Keep the space where the literal would join the next part of the expression. A left argument must be in the same run as its function: prefer `32•float∞` to `32 •float ∞`. `32 •float∞` gives the two items `32 ∞`. Between two names, keep both spaces: `x f 5`, not `x f5`.
 

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/syntax.qmd

@@ -34,7 +34,7 @@ Literals separated by spaces form a [strand](terms.qmd#term-strand), which is on
 
 ## Runs
 
-Outside brackets, spaces divide a statement into [runs](terms.qmd#term-run). A group in brackets, parentheses or braces counts as one token, even when it contains spaces. Each run must give one value: a subject, a function, or a lone operator such as the `/` in `+ / x`. A run that gives anything else is a `SYNTAX` error.
+Outside brackets, spaces divide a statement into [runs](terms.qmd#term-run). A group in brackets, parentheses or braces counts as one token, even when it contains spaces. Apart from the two operator rules below, each run must give one value: a subject, a function, or a lone operator such as the `/` in `+ / x`. A run that gives anything else is a `SYNTAX` error.
 
 BPL reads a statement in three steps:
 
@@ -42,7 +42,7 @@ BPL reads a statement in three steps:
 2. Each remaining run is wrapped in parentheses.
 3. The result reads as ordinary APL, right to left.
 
-So `a+b × c+d` is `(a+b)(×)(c+d)`, and `1 2+3` is `(1 2)+3`, not `(1)(2+3)`. A run that ends in a dyadic operator still needs a right operand, so it takes the run after it, which acts as one token: `⌊@ 10× x` is `(⌊@)(10×)(x)`, where `10×` is the operand of `@`. [Evaluation](evaluation.qmd) explains operands.
+So `a+b × c+d` is `(a+b)(×)(c+d)`, and `1 2+3` is `(1 2)+3`, not `(1)(2+3)`. A run that ends in a dyadic operator takes the next run as its right operand: `⌊@ 10× x` is `(⌊@)(10×)(x)`, where `10×` is the operand of `@`. A run that starts with an operator takes the previous run as its left operand: `≢⊢ ⌸x` is `(≢⊢)(⌸x)`, where `≢⊢` is the operand of `⌸`. [Evaluation](evaluation.qmd) explains operands.
 
 ```bpl
 a←1 ⋄ b←2 ⋄ c←3 ⋄ d←4 ⋄ a+b × c+d   ⍝ 21
@@ -51,6 +51,7 @@ a←1 ⋄ b←2 ⋄ c←3 ⋄ d←4 ⋄ a+b × c+d   ⍝ 21
 2×1 + 1                              ⍝ 3
 x←3 ⋄ x+1 ÷ 2                        ⍝ 2
 + / 1 2 3                            ⍝ 6
+x←0 1 1 0 1 1 ⋄ ≢⊢ ⌸x                ⍝ [2 4]ₓ
 ```
 
 ## Brackets, parentheses and braces

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/system/decompose.qmd

@@ -24,6 +24,13 @@ Where option `vectors` is false, `"svd"` and `"eigen"` give only `s` or `values`
 ⍴(["kind":"qr" "complete":$t]•decompose [1 2⋄3 4⋄5 6]).q  ⍝ [3 3]ₓ
 ```
 
+Option `rank`, a positive integer, makes `"svd"` give only the first `rank` singular values, with their vectors unless `vectors` is false. A randomized method computes them, in far less time than the full SVD of a large matrix takes. The result is an approximation. The faster the singular values beyond the `rank`th decay, the smaller its error. For a `rank` within 10 of the matrix's smaller side, the result is the full SVD's first `rank` columns.
+
+```bpl
+(["kind":"svd" "rank":1]•decompose [1 2⋄3 4⋄5 6]).s   ⍝ [9.525518091565104]
+⍴(["kind":"svd" "rank":1]•decompose [1 2⋄3 4⋄5 6]).v  ⍝ [2 1]ₓ
+```
+
 The determinant is `-.×m`. The `"lu"` factors give its sign, and the logarithm of its magnitude, which can't overflow:
 
 ```bpl
@@ -41,4 +48,4 @@ f←"cholesky" •decompose [4 2⋄2 3]
 "cholesky" •decompose⁻¹ f   ⍝ [4 2⋄2 3]
 ```
 
-Errors: `RANK` for an argument that isn't a matrix, or a factor of the wrong rank; `LENGTH` for `"eigen"`, `"cholesky"` or `"lu"` of a matrix that isn't square, or factors whose sizes don't agree; `DOMAIN` for an unknown decomposition or option, a `vectors` of false for a kind other than `"svd"` and `"eigen"`, a `complete` of true for a kind other than `"qr"`, an empty or nonnumeric matrix, `"cholesky"` of a matrix that isn't Hermitian positive definite, a missing factor, eigenvectors that aren't independent, or a `p` that doesn't hold each position once.
+Errors: `RANK` for an argument that isn't a matrix, or a factor of the wrong rank; `LENGTH` for `"eigen"`, `"cholesky"` or `"lu"` of a matrix that isn't square, or factors whose sizes don't agree; `DOMAIN` for an unknown decomposition or option, a `vectors` of false for a kind other than `"svd"` and `"eigen"`, a `complete` of true for a kind other than `"qr"`, a `rank` that isn't a positive integer or that's given for a kind other than `"svd"`, an empty or nonnumeric matrix, `"cholesky"` of a matrix that isn't Hermitian positive definite, a missing factor, eigenvectors that aren't independent, or a `p` that doesn't hold each position once.

{basedpl-0.1.45 → basedpl-0.1.46}/nbs/system/prefs.qmd

@@ -14,6 +14,7 @@
 | `width` | The widest line display shows. `∞` allows any width | The terminal's width in the REPL, `∞` elsewhere |
 | `tolerance` | The relative tolerance of approximate comparison of 64-bit floats, from 0 to `1E¯14`. Narrower floats compare exactly | `1E¯14` |
 | `float` | The width of new floats in bits, 16, 32 or 64 | `64` |
+| `threads` | The number of threads that large calls split across. `0` gives the default. `1` keeps every call on one thread | `0` |
 
 Display shows part of an array of more than `limit` items: the first and last `edges` positions of each axis longer than twice `edges`. `…` replaces the hidden columns, `⋮` the hidden rows, and `⋱` sits where they cross. A nested array follows the same rule on its own. A line wider than `width` hides columns in the same way, keeping as many at each end as fit. `⎕←` always shows every item, and rounds floats to `prec` as display does. [`⍕`](../glyphs/format.qmd) and source text always hold every item and every digit.
 
@@ -21,12 +22,15 @@ Display shows part of an array of more than `limit` items: the first and last `e
 
 `float` sets the default width of floats, in bits: the width of bare numbers in code parsed after the change, of numbers that `•csv`, `•json`, `•vfi` and `•image` read, of random numbers, and of floats that a function gives from exact arguments. Code already parsed keeps its numbers. A change partway through some code therefore applies from the next input, or from text that [`⍎`](../glyphs/execute.qmd) parses later. Leading `•prefs` calls on a literal record are the exception. They run before the rest of their code is parsed, as in the examples below. A script, a notebook cell or a line typed at the REPL can set its own width this way. In a module that [`•load`](load.qmd) runs, they run in order with the rest of its code. See [Numbers](../numbers.qmd#float-widths).
 
+`threads` sets how many threads this session's large calls split across. A call splits only when it has enough work to repay the extra threads. Float results can differ in their last bits between thread counts. The default, 0, uses the number in the `RAYON_NUM_THREADS` environment variable where it's set, and one thread for each core otherwise. 1 runs every call on the thread that evaluates the code. When several BPL processes run at once, such as a pool of Python workers, set 1 in each of them to keep them from competing for the cores. The browser build runs every call on one thread, whatever the setting.
+
 ```bpl
 •prefs ["tolerance":0] ⋄ 0.3=0.1+0.2    ⍝ $f
 •prefs ["tolerance":1E¯14] ⋄ 0.3=0.1+0.2    ⍝ $t
 •prefs ["tolerance":1E¯14] ⋄ 1ₛ=1.0000001ₛ    ⍝ $f
 •prefs ["float":32] ⋄ •storage 1.5    ⍝ "float32"
 •prefs ["float":64] ⋄ •storage 1.5    ⍝ "float64"
+•prefs ["threads":1] ⋄ "threads"⊃•prefs ⍬    ⍝ 1ₓ
 ```
 
 Errors: `DOMAIN` for an unknown setting or an invalid value.

{basedpl-0.1.45 → basedpl-0.1.46}/src/array/storage.rs

@@ -127,13 +127,15 @@ pub(crate) use with_int_pair;
 impl Width {
     /// The bytes that one integer of this width takes.
     fn bytes(self) -> usize { with_width!(self, T => std::mem::size_of::<T>()) }
-    /// Whether this width holds `n`.
+    /// Whether this width holds `n`. It is `#[inline]`, so that the incremental build doesn't call it for each width `narrowest` tries.
+    #[inline]
     fn holds(self, n: i64) -> bool { with_width!(self, T => T::narrowed(n).is_some()) }
     /// The narrowest width that holds `min`, `max` and every integer between. Every width holds the empty range, where `min` is above
     /// `max`.
     pub(crate) fn narrowest<T: Int>(min: T, max: T) -> Self {
         let (min, max) = (min.to_i64(), max.to_i64());
-        [Self::U8, Self::I16, Self::I32, Self::I64].into_iter().find(|w| min > max || w.holds(min) && w.holds(max)).expect("64 bits hold every integer")
+        for w in [Self::U8, Self::I16, Self::I32] { if min > max || w.holds(min) && w.holds(max) { return w } }
+        Self::I64
     }
     /// The narrowest width that holds every position below `bound`.
     pub(crate) fn below(bound: usize) -> Self { Self::narrowest(0, bound as i64 - 1) }
@@ -236,7 +238,7 @@ impl Kind {
 /// The compact kind of `source`'s items.
 fn source_kind(source: &Value) -> Option<Kind> {
     match source {
-        Value::Array(a) => a.data.items().kind(),
+        Value::Array(a) => a.storage().items().kind(),
         atom => item_kind(atom),
     }
 }
@@ -414,6 +416,14 @@ impl Storage {
         let mut kinds = data.iter().map(item_kind);
         let Some(kind) = kinds.next().flatten().and_then(|first| kinds.try_fold(first, |k, i| k.join(i?, widening))) else { return Self::mixed(data) };
         // Collecting from `data.iter()` sizes the compact buffer exactly. Consuming `data` would reuse its larger allocation.
+        Self::of_kind(kind, &data)
+    }
+    /// One item, in the compact storage of its own kind when it has one, as `compact` would hold it.
+    pub(super) fn one(item: &Value) -> Self {
+        match item_kind(item) { Some(kind) => Self::of_kind(kind, std::slice::from_ref(item)), None => Self::mixed(vec![item.clone()]) }
+    }
+    /// Compact storage of `kind` for `data`, whose items all have that kind or one it holds.
+    fn of_kind(kind: Kind, data: &[Value]) -> Self {
         match kind {
             Kind::Boolean => Self::Boolean(data.iter().map(|e| number(e).unwrap().as_bool().unwrap()).collect()),
             // The widest of the items' own widths holds every item.
@@ -728,7 +738,7 @@ impl Gather {
     }
     /// The gathered array, laid out by `layout`. An empty array takes `prototype`.
     pub(crate) fn finish(self, layout: Layout, prototype: impl Prototype) -> Result<Value, ErrorKind> {
-        let shape = layout.shape().to_vec();
+        let shape = crate::Shape::from(layout.shape());
         let value = match self.data {
             Storage::Mixed(ref d, _) if d.is_empty() && !self.open => Value::empty_of(shape, prototype.value(), true)?,
             data if data.len() == 0 => Value::empty(shape, prototype.value())?,

{basedpl-0.1.45 → basedpl-0.1.46}/src/array/text.rs

@@ -39,7 +39,7 @@ impl Value {
         if self.is_unit() {
             if let Value::Function(f) = self.at(0) {
                 let text = f.to_string();
-                return Self::characters(vec![text.chars().count()], text.chars().collect());
+                return Self::characters([text.chars().count()], text.chars().collect());
             }
         }
         // A keyed array formats as its display text, so its keys stay visible.
@@ -91,7 +91,7 @@ impl Value {
 
     fn formatted_cells(&self) -> Result<Self, ErrorKind> {
         use crate::display::{grid, Cell, Style};
-        if self.is_empty() { return Self::empty(vec![0], Value::Character(' ')); }
+        if self.is_empty() { return Self::empty([0], Value::Character(' ')); }
         let rank = self.shape().len();
         let columns = self.shape().last().copied().unwrap_or(1);
         let (mut size, mut matrix, mut rows) = (0, rank > 1, Vec::new());