basedpl 0.1.78__tar.gz → 0.1.79__tar.gz

{basedpl-0.1.78 → basedpl-0.1.79}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -110,6 +110,7 @@ dependencies = [
  "cranelift-module",
  "cranelift-native",
  "csv",
+ "fancy-regex",
  "flate2",
  "getrandom",
  "globset",
@@ -127,7 +128,6 @@ dependencies = [
  "plotters",
  "png",
  "rand",
- "regex",
  "roxmltree",
  "rustc-demangle",
  "rustix",
@@ -148,7 +148,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -162,7 +162,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "basedpl",
  "ctrlc",
@@ -180,7 +180,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -189,6 +189,21 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -712,6 +727,17 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
+[[package]]
+name = "fancy-regex"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20ed7f62ce0ae0da1a8b93c3c7104ab7e0760a74491e097c701fff966e945390"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -1071,9 +1097,9 @@ dependencies = [
 
 [[package]]
 name = "json5"
-version = "1.3.4"
+version = "1.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1628f14e201e5d6683248a22736547a083c2c176652d65b1068be73dab213a28"
+checksum = "e46128c9fb848c29097da3149e627cce5496d0b2820a9be06d12ee266c09c749"
 dependencies = [
  "serde",
  "ucd-trie",
@@ -1124,9 +1150,9 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
 [[package]]
 name = "libz-sys"
-version = "1.1.30"
+version = "1.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f710a23e6dbf193214fd46ca56a9d6864e550abe86202184532ae7275e46de19"
+checksum = "ff20308ecabd635a2dc1dd5834a86c462cca20efba1d5d3ddab1f8aea3455cb2"
 dependencies = [
  "cc",
  "pkg-config",
@@ -1582,18 +1608,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "regex"
-version = "1.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
 [[package]]
 name = "regex-automata"
 version = "0.4.18"
@@ -2450,7 +2464,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "anyhow",
  "rustymath",

{basedpl-0.1.78 → basedpl-0.1.79}/Cargo.toml

@@ -5,7 +5,7 @@ members = ["py"]
 join_comments = true
 
 [workspace.package]
-version = "0.1.78"
+version = "0.1.79"
 edition = "2024"
 rust-version = "1.98"
 license = "Apache-2.0"
@@ -103,7 +103,7 @@ png = ">=0.18.1, <1"
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 chrono = { version = ">=0.4.45, <0.5", features = ["unstable-locales"] }
 icu_normalizer = ">=2, <3"
-regex = "1"
+fancy-regex = "0.20"
 walkdir = ">=2.5.0, <3"
 globset = ">=0.4.20, <1"
 # Cranelift compiles a typed program's loops while BPL runs. The browser build has no JIT.
@@ -126,3 +126,6 @@ wasm-bindgen = ">=0.2.129, <0.3"
 [dev-dependencies]
 object = { version = ">=0.39.1, <1", default-features = false, features = ["read"] }
 rustc-demangle = ">=0.1.28, <1"
+
+[build-dependencies]
+serde_json = "1"

{basedpl-0.1.78 → basedpl-0.1.79}/DEV.md

@@ -241,7 +241,7 @@ Floats use IEEE NaN, infinity and signed zero. Comparison treats NaN as unequal;
 
 Under `•prefs ["kinds":"static"]`, a result's kind follows from its arguments' kinds alone, as `meta/kinds.md` describes. `Numeric` carries `kinds` and `int`. Until the `float` pref sets a width, `Numeric::set` gives new floats the width the kinds give, 32 bits under static kinds and 64 under dynamic kinds (`Kinds::float_width`). Whether the pref has set one lives in `settings::float_set`, outside `Numeric`: every call builds and copies a `Numeric`, and a Boolean field there cost about 14 instructions on each primitive call and 34 on each dfn call. A pervasive call on arrays plans before it computes. `plan::pervasive` builds a `plan::Pervasive` from the operands' kinds (`plan::Kind`: type, fixed width and weakness) and the settings, without reading items. It holds the settings with the fixed width that the operands give (`Numeric::for_kinds`), whether 16-bit floats compute in 32 bits, the kind that the call computes in (`computes_in`, which applies rustymath's `DType::common` after `Numeric::kind`), its kernel table (`computes`) and, under static kinds, every result's kind (`Pervasive::result`). Eager dispatch, fusion's deferral (`Pervasive::fuses`) and typed programs read the same plan. Products and folds plan the same way. `plan::Product` holds `g`'s pervasive plan and the settings under which `f` folds its results (`Product::folds`). `plan::Fold` holds a fold's or scan's settings and its operands' kinds. Eager products, folds and scans read them, as typed programs do. Comparisons, `⌈ ⌊` and bitwise functions compute at their arguments' storage width instead, where their results are the same at every width (`pervasive::first_kind`). A comparison between integers and a whole float that stands for an integer computes on integers, through `Pervasive::computes`, as does a residue by such a float or a residue scan from one, whose results then convert to floats (`plan::whole_float`). Literals, values computed only from literals, and Python's scalar arguments are weak (`Number::is_weak`). Before a call, `Primitive::weakened` converts a weak number beside a strong one to the width that rustymath's `DType::common_weak` gives it, or to a fixed integer's width where it fits. The loops keep the failed results that `keeps` names: floats' NaNs, and the wrapped integers of objects that report `WRAPS`. The kernel tables choose float `⌊ ⌈ ×` and wrapping negation from `run.numeric()`. `Stored::build_at` keeps complex results complex. `Primitive::number` gives every pervasive result on numbers, as well as each step of the fold of numbers. Under static kinds, `statically` converts it to the kind that the call's plan gives. A static call on ordinary integers that an integer kernel takes runs that kernel at the `int` width instead, as a call on fixed integers runs it at theirs (`Primitive::integer_kernel`). Under dynamic kinds, a call on two numbers stays outside plans, because the type of its result depends on their values. `Number::wrapped` and `Value::wrapped` wrap an exact integer result to the integer width, the fixed width that `Numeric::for_kinds` finds among a call's operands, or the `int` width under static kinds. Under static kinds a strong ordinary integer is a fixed integer of the width it computes at, the `int` width joined with its storage width (`plan::Kind::stored`). Every static call on integer arrays then computes under a fixed width. Weak integers have no fixed width. NEP 50 decides theirs, as before. Display marks a fixed integer of the `int` width with plain `ₓ` (`Mark::integer`). A fixed kernel that fails where a result doesn't fit, as lcm and binomial coefficients can, gives the exact result wrapped (`Primitive::fixed_number`). `statically` uses them, and so do the functions that compute exactly, such as `⊥`, `⌻` and the determinant. Where integers wrap, a function whose results are approximate, such as `⌹` or polar parts, computes integers as floats of the width that their division gives (`plan::Kind::approximate`). `∂` converts the integers that wrap in its argument to those floats before it runs its function (`derivative::differentiate`). `Number::parse` keeps complex literals and checks integer literals against the `int` width.
 
-Settings live once for the whole process, in `settings.rs`, and are read from there, not passed through functions, except where a read is slow and on a hot path. Each setting that calls and scalar operations read is an atomic: the numeric settings, the hanzi aliases, the `batch` pref, the verifier flag, the fusion report flag, fusion's small sizes and the compile setting. The display settings sit behind one lock. `•prefs` writes them, the lexer writes a source's leading `•prefs` header as it reads it, and `settings::reset` restores the defaults, as `]clear` and the test harnesses do. A module that `•load` runs changes the settings for the whole process. Nothing restores them when it returns. Rustymath holds the thread count, the one setting that it reads itself, and `•prefs` writes it there. Each call reads the store once where it starts. Pervasive calls, folds and products read it as they plan (`Primitive::pervasive_mapped`). A dfn call reads it as it looks for its program (`program::call`). So do `Domain::of` and the lexer. Values derived from the settings within a call stay explicit arguments. A call's plan holds the settings it computes under. A pending array computes under the plans that its calls made, whatever settings are in force when it computes. A pending conversion holds the settings that give its floor's tolerance (`Step::Convert`'s `numeric`). A dfn's programs are found by the settings they were traced under (`program::Key`). Under other settings, the dfn traces a new program. The loop structs keep the settings because their closures run on rustymath's worker threads. `Number`'s tolerance methods and `Primitive::number` take them because they run once per item. The parser's leaves take a width marker's width, and `matches_within` takes `⍣∞`'s convergence tolerance. Imports build complex numbers with `Number::complex_in_session`: Python's `_Session.array` and the JSON protocol's `request`. JavaScript values hold no complex numbers.
+Settings live once for the whole process, in `settings.rs`, and are read from there, not passed through functions, except where a read is slow and on a hot path. Each setting that calls and scalar operations read is an atomic: the numeric settings, the hanzi aliases, the `batch` pref, the verifier flag, the fusion report flag, fusion's sizes, which `settings::set_sizes` sets, and the compile setting. The display settings sit behind one lock. `•prefs` writes them, the lexer writes a source's leading `•prefs` header as it reads it, and `settings::reset` restores the defaults, as `]clear` and the test harnesses do. A module that `•load` runs changes the settings for the whole process. Nothing restores them when it returns. Rustymath holds the thread count, the one setting that it reads itself, and `•prefs` writes it there. Each call reads the store once where it starts. Pervasive calls, folds and products read it as they plan (`Primitive::pervasive_mapped`). A dfn call reads it as it looks for its program (`program::call`). So do `Domain::of` and the lexer. Values derived from the settings within a call stay explicit arguments. A call's plan holds the settings it computes under. A pending array computes under the plans that its calls made, whatever settings are in force when it computes. A pending conversion holds the settings that give its floor's tolerance (`Step::Convert`'s `numeric`). A dfn's programs are found by the settings they were traced under (`program::Key`). Under other settings, the dfn traces a new program. The loop structs keep the settings because their closures run on rustymath's worker threads. `Number`'s tolerance methods and `Primitive::number` take them because they run once per item. The parser's leaves take a width marker's width, and `matches_within` takes `⍣∞`'s convergence tolerance. Imports build complex numbers with `Number::complex_in_session`: Python's `_Session.array` and the JSON protocol's `request`. JavaScript values hold no complex numbers.
 
 `Numeric::mathish_at(width)` owns Mathish eligibility: the preference must be on, kinds dynamic and the calculation ordinary exact, f64 or complex128. Fixed-integer operations are excluded even when computing at f64. Kernels select their numerical objects before the loop. Mathish comparison tolerance is `1E-14`. f32/f16 compare exactly. Fixed-point convergence uses four ulps at those widths and `1E-14` at f64, independently of Mathish. Index/count/Boolean/character-offset conversion uses `near_integer` with the fixed default tolerance. The numerical objects come from rustymath. Use independent inside/outside-tolerance tests with exact/mixed controls rather than language comparison as its own oracle.
 

{basedpl-0.1.78 → basedpl-0.1.79}/PKG-INFO

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

basedpl-0.1.79/build.rs

@@ -0,0 +1,58 @@
+use std::{env, fs, path::Path};
+
+fn page_text(path: &Path) -> String {
+    let text = fs::read_to_string(path).unwrap();
+    if path.extension().is_none_or(|s| s != "ipynb") { return text; }
+    let notebook: serde_json::Value = serde_json::from_str(&text).unwrap();
+    let language = notebook["metadata"]["kernelspec"]["language"].as_str().unwrap_or("bpl");
+    let mut text = String::new();
+    for cell in notebook["cells"].as_array().unwrap() {
+        let source = match &cell["source"] {
+            serde_json::Value::String(s) => s.clone(),
+            lines => lines.as_array().unwrap().iter().map(|s| s.as_str().unwrap()).collect(),
+        };
+        match cell["cell_type"].as_str().unwrap() {
+            "markdown" => text.push_str(&source),
+            "code" => text.push_str(&format!("```{language}\n{source}\n```")),
+            _ => continue,
+        }
+        text.push_str("\n\n");
+    }
+    text
+}
+
+/// Embeds the reference pages and guides, including notebook source but not outputs.
+fn main() {
+    println!("cargo::rustc-check-cfg=cfg(web)");
+    if env::var("CARGO_CFG_TARGET_ARCH").is_ok_and(|a| a == "wasm32") && env::var("CARGO_CFG_TARGET_OS").is_ok_and(|o| o == "unknown") {
+        println!("cargo::rustc-cfg=web");
+    }
+    let mut entries = Vec::new();
+    for dir in ["", "glyphs", "system"] {
+        let folder = Path::new("nbs").join(dir);
+        println!("cargo::rerun-if-changed={}", folder.display());
+        let mut paths: Vec<_> = fs::read_dir(&folder).unwrap().map(|entry| entry.unwrap().path())
+            .filter(|path| path.extension().is_some_and(|s| s == "qmd" || s == "ipynb")).collect();
+        paths.sort();
+        for path in &paths {
+            let stem = path.file_stem().unwrap().to_str().unwrap();
+            let name = if dir.is_empty() { stem.to_owned() } else { format!("{dir}/{stem}") };
+            let mut help = page_text(path);
+            if !dir.is_empty() {
+                for target in &paths {
+                    let file = target.file_name().unwrap().to_str().unwrap();
+                    help = help.replace(&format!("]({file}"), &format!("]({dir}/{file}"));
+                }
+                help = help.replace("](../", "](");
+            }
+            let title = help.lines().find_map(|l| l.strip_prefix("# ")).unwrap_or(stem);
+            let aliases: Vec<&str> = if dir == "glyphs" { vec![stem] } else if dir == "system" {
+                let mut fenced = false;
+                help.lines().filter(|line| { fenced ^= line.starts_with("```"); !fenced && line.starts_with('#') })
+                    .flat_map(|line| line.split('`').skip(1).step_by(2)).filter(|name| name.starts_with(['•', '$'])).collect()
+            } else { Vec::new() };
+            entries.push(format!("Page {{ name: {name:?}, title: {title:?}, aliases: &{aliases:?}, text: {help:?} }}"));
+        }
+    }
+    fs::write(Path::new(&env::var("OUT_DIR").unwrap()).join("help.rs"), format!("const HELP: &[Page] = &[{}];", entries.join(",\n"))).unwrap();
+}

{basedpl-0.1.78 → basedpl-0.1.79}/nbs/getting-started.ipynb

@@ -32,7 +32,7 @@
    "source": [
     "## First calculations\n",
     "\n",
-    "Run `bpl` to open the [REPL](repl.qmd). Type an expression and press Enter. `⍝` starts a comment. The examples use comments to show each result.\n",
+    "Run `bpl` to open the [REPL](repl.qmd). Type an expression and press Enter. `⍝` starts a comment.\n",
     "\n",
     "BPL evaluates right to left. Parentheses group, and so do spaces. BPL evaluates each part between spaces first."
    ]
@@ -72,9 +72,9 @@
     }
    ],
    "source": [
-    "2×3+4                 ⍝ 14\n",
-    "(2×3)+4               ⍝ 10\n",
-    "2×3 + 4               ⍝ 10"
+    "2×3+4\n",
+    "(2×3)+4\n",
+    "2×3 + 4"
    ]
   },
   {
@@ -102,7 +102,7 @@
     }
    ],
    "source": [
-    "10+1 2 3              ⍝ 11 12 13"
+    "10+1 2 3"
    ]
   },
   {
@@ -139,8 +139,8 @@
     }
    ],
    "source": [
-    "v←⍳5 ⋄ v              ⍝ 0 1 2 3 4\n",
-    "+/⍳5                  ⍝ 10"
+    "v←⍳5 ⋄ v\n",
+    "+/⍳5"
    ]
   },
   {
@@ -187,8 +187,8 @@
     }
    ],
    "source": [
-    "1÷3                   ⍝ 0.3333333333333333\n",
-    "1ₓ÷3ₓ                 ⍝ 1ᵣ3"
+    "1÷3\n",
+    "1ₓ÷3ₓ"
    ]
   },
   {
@@ -216,7 +216,7 @@
     }
    ],
    "source": [
-    "1j2×1j¯2              ⍝ 5"
+    "1j2×1j¯2"
    ]
   },
   {
@@ -244,7 +244,7 @@
     }
    ],
    "source": [
-    "+/2 3⍴⍳6              ⍝ 3 12"
+    "+/2 3⍴⍳6"
    ]
   },
   {

{basedpl-0.1.78 → basedpl-0.1.79}/nbs/regex.ipynb

@@ -22,7 +22,7 @@
        "\n",
        "`•r pattern` compiles a regular expression. It returns a keyed vector of two functions that share the pattern. `p.matches text` gives a table of the matches, as a record of columns: `text`, the matched text; `position`, its position in characters from 0; and `groups`, the text of each group, which is empty for a group that took no part. `template p.replace text` replaces each match with `template`, expanded with the match's groups.\n",
        "\n",
-       "Natively the pattern is a Rust regex, with [the regex crate's syntax](https://docs.rs/regex/latest/regex/#syntax). Flags go in the pattern, as in `(?i)`, and templates use `$1`, `${name}` and `$$`. In the browser the pattern is a JavaScript regular expression, with [JavaScript's syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions), and templates use `$1`, `$<name>` and `$$`. [Regular expressions](regex.ipynb) covers each function.\n",
+       "Natively the pattern uses [fancy-regex's syntax](https://docs.rs/fancy-regex/latest/fancy_regex/#syntax), including lookaround and backreferences. Flags go in the pattern, as in `(?i)`, and templates use `$1`, `${name}` and `$$`. A search that exceeds the engine's backtracking limit raises `DOMAIN`. In the browser the pattern is a JavaScript regular expression, with [JavaScript's syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions), and templates use `$1`, `$<name>` and `$$`. [Regular expressions](regex.ipynb) covers each function.\n",
        "\n",
        "```bpl\n",
        "p←•r \"([a-z]+)([0-9]+)\"\n",
@@ -33,13 +33,11 @@
        "Errors: `DOMAIN` for invalid patterns and non-text arguments; `SYNTAX` for the wrong valence; `LIMIT` for oversized results.\n"
       ],
       "text/plain": [
-       "function\n",
-       "\n",
        "# `•r` — Regular expressions\n",
        "\n",
        "`•r pattern` compiles a regular expression. It returns a keyed vector of two functions that share the pattern. `p.matches text` gives a table of the matches, as a record of columns: `text`, the matched text; `position`, its position in characters from 0; and `groups`, the text of each group, which is empty for a group that took no part. `template p.replace text` replaces each match with `template`, expanded with the match's groups.\n",
        "\n",
-       "Natively the pattern is a Rust regex, with [the regex crate's syntax](https://docs.rs/regex/latest/regex/#syntax). Flags go in the pattern, as in `(?i)`, and templates use `$1`, `${name}` and `$$`. In the browser the pattern is a JavaScript regular expression, with [JavaScript's syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions), and templates use `$1`, `$<name>` and `$$`. [Regular expressions](regex.ipynb) covers each function.\n",
+       "Natively the pattern uses [fancy-regex's syntax](https://docs.rs/fancy-regex/latest/fancy_regex/#syntax), including lookaround and backreferences. Flags go in the pattern, as in `(?i)`, and templates use `$1`, `${name}` and `$$`. A search that exceeds the engine's backtracking limit raises `DOMAIN`. In the browser the pattern is a JavaScript regular expression, with [JavaScript's syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions), and templates use `$1`, `$<name>` and `$$`. [Regular expressions](regex.ipynb) covers each function.\n",
        "\n",
        "```bpl\n",
        "p←•r \"([a-z]+)([0-9]+)\"\n",
@@ -63,7 +61,7 @@
    "id": "f6464060",
    "metadata": {},
    "source": [
-    "Natively, patterns use [Rust regex syntax](https://docs.rs/regex/latest/regex/#syntax). In the browser they use [JavaScript's](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions). `p.matches` gives a table of the matches, as a record of columns. Here `p` finds runs of digits:"
+    "Natively, patterns use [fancy-regex syntax](https://docs.rs/fancy-regex/latest/fancy_regex/#syntax), including lookaround and backreferences. Exceeding the engine's backtracking limit raises `DOMAIN`. In the browser they use [JavaScript's](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions). `p.matches` gives a table of the matches, as a record of columns. Here `p` finds runs of digits:"
    ]
   },
   {

{basedpl-0.1.78 → basedpl-0.1.79}/nbs/repl.qmd

@@ -86,11 +86,26 @@ An unclosed delimiter gives a continuation prompt. Closing it evaluates the comp
 
 Inside brackets and parentheses, a line break means `⋄`, so each line of a bracket list is a row of the array.
 
+## Help
+
+`]help` lists the topics available offline. Open a topic by name, as in `]help indexing`, or enter part of its name or title to find matching topics. Names and glyphs work too:
+
+| Command | Effect |
+|---|---|
+| `]help indexing` | The indexing guide |
+| `]help +` | Help for a name or glyph |
+| `]help mean -source` | Definition source |
+| `]help llms` | The concise language reference |
+| `]help ?` | Help for the guard glyph |
+| `]help? index(?!ing)` | Regex search over all help text |
+
+Everything after `]help?` is the pattern, without quotes. Search ignores case by default. Results put name/title matches before headings, then body text, and show the command to open each topic. Search uses the same platform-specific regex syntax as [`•r`](system/r.qmd). For example, `]help? index|select` finds both terms. Natively, `(?-i)` makes the pattern case-sensitive.
+
 ## Array and function display
 
 Interactive sessions draw arrays in boxes, show functions as trees, and box output made inside functions. [`•prefs`](system/prefs.qmd) reads and changes these settings: `•prefs ["box":$f]` turns boxes off, and `•prefs ⍬` shows every setting. Batch and JSON sessions start without boxes, and so does Python until IPython loads BPL's magics.
 
-Matrices, nested arrays and strings have boxes, axis arrows and a type marker on the bottom edge. Other vectors stay plain. Their plain form shows their kind, keys and axis name, as in `[2 3 5]ₓ`, `[1.5 2.5]ₛ` and `$t $f`. The marker names the storage: `ₓ` for exact integers, `~` for floats, `j` for complex numbers, `─` for characters, `∊` for nested arrays and `+` for mixed storage, whose items keep their own kinds. Numbers inside an `ₓ` box carry no mark of their own. Without boxes, a matrix whose numbers share a marked kind shows as its literal laid out in rows, with one mark after the brackets. A keyed matrix shows that mark in its corner. Enter a function name to see its tree.
+Matrices and nested arrays have boxes, axis arrows and a type marker on the bottom edge. Other vectors stay plain. Character vectors display as quoted strings, including inside arrays. Their plain form shows their kind, keys and axis name, as in `[2 3 5]ₓ`, `[1.5 2.5]ₛ` and `$t $f`. The marker names the storage: `ₓ` for exact integers, `~` for floats, `j` for complex numbers, `─` for characters, `∊` for nested arrays and `+` for mixed storage, whose items keep their own kinds. Numbers inside an `ₓ` box carry no mark of their own. Without boxes, a matrix whose numbers share a marked kind shows as its literal laid out in rows, with one mark after the brackets. A keyed matrix shows that mark in its corner. Enter a function name to see its tree.
 
 An array of more than 1000 items shows only the first and last 3 positions of each long axis. `…` replaces the hidden columns, `⋮` the hidden rows, and `⋱` sits where they cross. The `limit` and `edges` settings of `•prefs` change these numbers. `⎕←` prints every item.
 
@@ -109,9 +124,6 @@ An array of more than 1000 items shows only the first and last 3 positions of ea
 
 | Command | Effect |
 |---|---|
-| `]help +` | Help for a name or glyph |
-| `]help mean -source` | Definition source |
-| `]help llms` | The index of BPL's documentation for LLMs, [llms.txt](llms.txt) |
 | `]Display [[1 2] [3 4]]` | Draw one array in a box, whatever the settings |
 | `]dissect expression` | Show the bound expression before its result |
 | `]clear` | Remove every name and restore the starting display settings |

{basedpl-0.1.78 → basedpl-0.1.79}/nbs/system/prefs.qmd

@@ -4,7 +4,7 @@
 
 | Setting | Holds | Default |
 |---|---|---|
-| `box` | `$t` draws matrices, nested arrays and strings in boxes, and leaves other vectors plain | `$t` in the REPL, the BPL Jupyter kernel and IPython once it loads BPL's magics, `$f` elsewhere |
+| `box` | `$t` draws matrices and nested arrays in boxes. Simple vectors and strings stay plain | `$t` in the REPL, the BPL Jupyter kernel and IPython once it loads BPL's magics, `$f` elsewhere |
 | `trees` | `$t` shows functions and dissected expressions as trees; `$f` uses linear notation. Independent of `box` | as `box` |
 | `fns` | `$f` leaves output made inside functions unboxed | as `box` |
 | `dissect` | `$t` shows the bound expression before each normal result, using `trees` | `$f` |
@@ -23,7 +23,11 @@
 | `batch` | `$t` lets each [map](../terms.qmd#term-map) call its operand once on all its cells together, as described below | `$t` |
 | `seed` | A nonnegative whole number that seeds the session's random numbers | A seed from the operating system |
 
-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. Text with line breaks counts its lines, not its characters. Text of more than `limit` lines shows its first and last `edges` lines, with `⋮` on a line between. A nested array follows the same rule on its own. So does an array that a function holds, such as `⍳10000` in `(⍳10000)↣+`. 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/thorn.qmd) and source text always hold every item and every digit.
+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 hidden columns, `⋮` hidden rows, and `⋱` sits where they cross. A nested array follows the same rule on its own. So does an array that a function holds, such as `⍳10000` in `(⍳10000)↣+`. A line wider than `width` keeps as many positions at each end as fit.
+
+Character vectors display as quoted strings, including inside arrays and with `box` on. Embedded quotes are doubled and line breaks stay as line breaks. Other control characters display as escapes such as `\t`. `limit` counts characters in a single-line string and lines in a multiline string. A preview keeps a prefix and up to `edges` trailing characters or lines, with `…` or a `⋮` line between. At least half the budget goes to the prefix. Long lines use the same prefix-and-tail rule to fit `width`.
+
+`⎕←` always shows every item and rounds floats to `prec` as display does. [`⍕`](../glyphs/thorn.qmd) and source text always hold every item and every digit. `"-" •nput text` writes raw text without quotes or truncation.
 
 `notation` changes generated function and operator displays, including trees and dissected expressions. Dfn source, strings, record keys and field separators stay unchanged. Generated source and structural APIs keep canonical APL spellings.
 

{basedpl-0.1.78 → basedpl-0.1.79}/nbs/system/r.qmd

@@ -2,7 +2,7 @@
 
 `•r pattern` compiles a regular expression. It returns a keyed vector of two functions that share the pattern. `p.matches text` gives a table of the matches, as a record of columns: `text`, the matched text; `position`, its position in characters from 0; and `groups`, the text of each group, which is empty for a group that took no part. `template p.replace text` replaces each match with `template`, expanded with the match's groups.
 
-Natively the pattern is a Rust regex, with [the regex crate's syntax](https://docs.rs/regex/latest/regex/#syntax). Flags go in the pattern, as in `(?i)`, and templates use `$1`, `${name}` and `$$`. In the browser the pattern is a JavaScript regular expression, with [JavaScript's syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions), and templates use `$1`, `$<name>` and `$$`. [Regular expressions](../regex.ipynb) covers each function.
+Natively the pattern uses [fancy-regex's syntax](https://docs.rs/fancy-regex/latest/fancy_regex/#syntax), including lookaround and backreferences. Flags go in the pattern, as in `(?i)`, and templates use `$1`, `${name}` and `$$`. A search that exceeds the engine's backtracking limit raises `DOMAIN`. In the browser the pattern is a JavaScript regular expression, with [JavaScript's syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions), and templates use `$1`, `$<name>` and `$$`. [Regular expressions](../regex.ipynb) covers each function.
 
 ```bpl
 p←•r "([a-z]+)([0-9]+)"

{basedpl-0.1.78 → basedpl-0.1.79}/python/basedpl/bpltests.py

@@ -374,22 +374,26 @@ def instructions(
     runs=3, # Processes at each value of `N`, of which the lowest count is used
     bpl:Annotated[Path, {'nargs':'+'}]=None # A native `bpl` to count, such as a copy saved before a change, or a list of builds to compare, where `None` is the installed one; None: the installed one
 ):
-    "The instructions that each case retires per unit of `N`, on one thread. A case that doesn't name `N` runs once per step inside `{case ⋄ ⍵}⍣N 0`. That dfn's own call adds about 1,900 instructions per step. For each pair of successive values of `N`, the difference between fresh `bpl` processes, divided by the difference in `N`, cancels startup and `setup`. The result is the median of those slopes. The median drops a one-off cost that starts once `N` passes some size, because such a cost falls between only one pair. Unlike timings, instruction counts don't vary with load or code layout, so they show per-call changes of a few percent. A case that names `N` must make one call per step of `N`, as `⍣` does: a map such as `f¨N⍴0` calls a dfn once on all its cells, so it gives no per-call cost. Given several builds, it gives `ByBuild`, counting each case at the same values of `N` on every build. Each build stays pinned for the whole count (`pinned_each`)."
+    "The instructions that each case retires per unit of `N`, on one thread. A case that doesn't name `N` runs once per step inside `{case ⋄ ⍵}⍣N 0`. That dfn's own call adds about 1,900 instructions per step. For each pair of successive values of `N`, the difference between fresh `bpl` processes, divided by the difference in `N`, cancels startup and `setup`. The result is the median of those slopes. The median drops a one-off cost that starts once `N` passes some size, because such a cost falls between only one pair. Unlike timings, instruction counts don't vary with load or code layout, so they show per-call changes of a few percent, and its processes run at once, one for each core. A case that names `N` must make one call per step of `N`, as `⍣` does: a map such as `f¨N⍴0` calls a dfn once on all its cells, so it gives no per-call cost. Given several builds, it gives `ByBuild`, counting each case at the same values of `N` on every build. Each build stays pinned for the whole count (`pinned_each`)."
     cases = listify(cases)
     builds = listify(bpl) or [None]
-    def count(code, n, build, runs=runs): return min(_retired(_program(code, n, setup), build) for _ in range(runs))
-    def steps(code, build):
-        if counts: return counts
-        rough = max(1, (count(code, 1_000, build, 1) - count(code, 0, build, 1)) / 1_000)
-        # Each value is at least one more than the last, for a case that retires more than `_SPAN` instructions a step, whose warm-up is then a small share of a step.
-        return list(accumulate((round((_SETTLE + i*_SPAN)/rough) for i in range(4)), lambda last, n: max(n, last + 1)))
-    def per_step(code, ns, build):
-        cs = [count(code, n, build) for n in ns]
-        return statistics.median((c1-c0)/(n1-n0) for n0, n1, c0, c1 in zip(ns, ns[1:], cs, cs[1:]))
-    stepped = [(case, _stepped(case, force)) for case in cases]
-    with pinned_each(builds) as paths:
-        ns = [steps(code, paths[0]) for _, code in stepped]
-        each = [Instructions((case, per_step(code, n, build)) for (case, code), n in zip(stepped, ns)) for build in paths]
+    stepped = [_stepped(case, force) for case in cases]
+    def slope(ns, cs): return statistics.median((c1-c0)/(n1-n0) for n0, n1, c0, c1 in zip(ns, ns[1:], cs, cs[1:]))
+    with pinned_each(builds) as paths, ThreadPoolExecutor(os.cpu_count()) as pool:
+        def lowest(jobs, runs=runs):
+            "The lowest count of `runs` processes for each `(code, n, build)` in `jobs`, from processes that run at once."
+            got = list(pool.map(lambda job: _retired(_program(job[0], job[1], setup), job[2]), [job for job in jobs for _ in range(runs)]))
+            return [min(got[i:i+runs]) for i in range(0, len(got), runs)]
+        if counts: ns = [counts]*len(cases)
+        else:
+            rough = lowest([(code, n, paths[0]) for code in stepped for n in (1_000, 0)])
+            # Each value is at least one more than the last, for a case that retires more than `_SPAN` instructions a step, whose warm-up is then a small share of a step.
+            ns = [list(accumulate((round((_SETTLE + i*_SPAN)/max(1, (c1-c0)/1_000)) for i in range(4)), lambda last, n: max(n, last + 1)))
+                  for c1, c0 in zip(rough[::2], rough[1::2])]
+        each = []
+        for build in paths:
+            cs = iter(lowest([(code, n, build) for code, steps in zip(stepped, ns) for n in steps]))
+            each.append(Instructions((case, slope(steps, [next(cs) for _ in steps])) for case, steps in zip(cases, ns)))
     return each[0] if len(builds) == 1 else ByBuild(each, builds)
 
 class FunctionCounts(list):

{basedpl-0.1.78 → basedpl-0.1.79}/python/basedpl/ipython.py

@@ -1,5 +1,6 @@
 "IPython help and completion for BPL functions and sessions."
 import re
+from html import escape
 from IPython.core.completer import context_matcher, SimpleCompletion
 from . import Function, _Workspace
 
@@ -7,7 +8,8 @@ from . import Function, _Workspace
 def inspection_mime(info, detail=False):
     "Render structured BPL inspection as an IPython MIME bundle."
     text = info['source' if detail else 'help']
-    return {'text/plain':text, 'text/markdown':f'```apl\n{text}\n```' if detail else text}
+    return {'text/plain':text, 'text/markdown':f'```apl\n{text}\n```' if detail else text,
+        'text/html':f'<pre>{escape(text)}</pre>'}
 
 
 

{basedpl-0.1.78 → basedpl-0.1.79}/src/array/text.rs

@@ -7,6 +7,12 @@ use crate::transform::Plain;
 /// Text as a double-quoted string literal.
 pub(crate) fn quoted(text: &str) -> String { format!("\"{}\"", text.replace('"', "\"\"")) }
 
+fn excerpt(len: usize, limit: usize, edges: usize) -> impl Iterator<Item = Option<usize>> {
+    let tail = edges.min(limit / 2);
+    let (head, end) = if len > limit { (limit - tail, len - tail) } else { (len, len) };
+    (0..head).map(Some).chain((head < end).then_some(None)).chain((end..len).map(Some))
+}
+
 /// Whether `test` holds for a character of source text outside brackets, parentheses, braces and quotes.
 fn outside(text: &str, test: impl Fn(char) -> bool) -> bool {
     let (mut depth, mut chars) = (0, text.chars());
@@ -159,7 +165,7 @@ impl Value {
             Plain::Array(_) => {
                 if self.shows_names(el) { return self.named_literal(el); }
                 let edges = if self.shape().len() == 1 { el.last(self.shape()) } else { el.edges(self.shape()) };
-                if self.string_literal().is_some() { return quoted(&self.elided_text(el)); }
+                if self.string_literal(el.display).is_some() { return quoted(&self.elided_text(el)); }
                 if let Some(s) = crate::keyed::name(self) {
                     return format!(",•ucs {}", s.chars().map(|c| (c as u32).to_string()).collect::<Vec<_>>().join(" "));
                 }
@@ -179,14 +185,20 @@ impl Value {
     /// The items display shows of a vector, with `None` for the gap that `edges` leaves.
     fn shown(&self, edges: Option<usize>) -> impl Iterator<Item = Option<Value>> + '_ { positions(self.len(), edges).map(|i| i.map(|i| self.at(i))) }
 
-    /// A character vector's characters as display shows them. Text with line breaks counts its lines against `limit`, and past it keeps the first and last `edges` lines, with `⋮` on a line between. Other text counts its characters, and keeps as many at each end as a last axis keeps, with `…` between.
+    /// A string preview, counting multiline text in lines and each shown line in characters.
     pub(crate) fn elided_text(&self, el: Elide) -> String {
-        if let Some(text) = crate::keyed::name(self) && text.contains('\n') {
-            let Some(e) = el.edges(&[text.split('\n').count()]) else { return text.to_string() };
-            let lines: Vec<&str> = text.split('\n').collect();
-            return positions(lines.len(), Some(e)).map(|i| i.map_or("⋮", |i| lines[i])).collect::<Vec<_>>().join("\n");
-        }
-        self.shown(el.last(self.shape())).map(|c| match c { Some(Self::Character(c)) => c, _ => '…' }).collect()
+        let text = crate::keyed::name(self).expect("a character vector");
+        let lines: Vec<_> = text.split('\n').collect();
+        let multiline = lines.len() > 1;
+        let columns = el.columns.min(if multiline { usize::MAX } else { el.limit });
+        excerpt(lines.len(), if multiline { el.limit } else { usize::MAX }, el.edges).map(|line| {
+            let Some(line) = line else { return "⋮".to_string() };
+            let chars: Vec<_> = lines[line].chars().collect();
+            excerpt(chars.len(), columns, el.edges).map(|i| match i {
+                Some(i) if chars[i].is_control() => chars[i].escape_default().to_string(),
+                Some(i) => chars[i].to_string(), None => "…".to_string(),
+            }).collect::<String>()
+        }).collect::<Vec<_>>().join("\n")
     }
 
     /// Text for each shown item of a vector, written by `item`, with `…` for the gap that `edges` leaves.
@@ -263,9 +275,9 @@ impl Value {
     /// Whether plain display shows the vector as a strand: a vector of two or more numbers, characters or strings. Exact integers show in brackets instead.
     pub(crate) fn is_strand(&self, el: Elide) -> bool {
         matches!(self, Self::Array(_)) && self.shape().len() == 1 && self.len() >= 2 && !self.has_keys() && !self.shows_names(el)
-            && self.string_literal().is_none() && !matches!(self.shown_kind(), Some((rustymath::buffer::DType::Integer(_), _))) && match self.as_items() {
+            && self.string_literal(el.display).is_none() && !matches!(self.shown_kind(), Some((rustymath::buffer::DType::Integer(_), _))) && match self.as_items() {
                 Items::Values(items) => {
-                    items.iter().all(|e| matches!(e, Self::Number(_)) || matches!(e, Self::Character(c) if !c.is_control()) || e.string_literal().is_some())
+                    items.iter().all(|e| matches!(e, Self::Number(_)) || matches!(e, Self::Character(c) if !c.is_control()) || e.string_literal(el.display).is_some())
                 }
                 Items::Compact(View::Characters(cs)) => cs.iter().all(|c| !c.is_control()),
                 _ => true,
@@ -315,15 +327,15 @@ impl Value {
 
     /// A major cell as one part of array notation: a vector's items side by side, a higher rank in its own notation, or one item. A row with one item needs its own brackets, because a single item would be a cell by itself. `edges` elides the whole array's positions.
     fn row(&self, item: fn(&Self, Elide) -> String, el: Elide, edges: Option<usize>) -> String {
-        if self.shape().len() == 1 && !self.has_keys() && self.string_literal().is_none() {
+        if self.shape().len() == 1 && !self.has_keys() && self.string_literal(el.display).is_none() {
             if self.len() == 1 { return format!("[{}]", item(&self.at(0), el)); }
             self.shown_items(edges, |e| item(&e, el)).join(" ")
         } else if self.shape().len() > 1 && !self.has_keys() { self.block_literal(item, el, edges) }
         else { item(self, el) }
     }
 
-    /// A character vector as a double-quoted literal, or `None` when it holds a control character other than a newline.
-    fn string_literal(&self) -> Option<String> {
-        if let Self::Array(_) = self { crate::keyed::name(self).filter(|s| !s.chars().any(|c| c.is_control() && c != '\n')).map(|s| quoted(&s)) } else { None }
+    /// A quoted character vector. Source excludes control characters other than a newline.
+    fn string_literal(&self, display: bool) -> Option<String> {
+        if let Self::Array(_) = self { crate::keyed::name(self).filter(|s| display || !s.chars().any(|c| c.is_control() && c != '\n')).map(|s| quoted(&s)) } else { None }
     }
 }

{basedpl-0.1.78 → basedpl-0.1.79}/src/array.rs

@@ -1001,7 +1001,7 @@ impl Value {
     }
 }
 
-impl fmt::Display for Value { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&crate::display::plain(self, Elide::NONE)) } }
+impl fmt::Display for Value { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&crate::display::plain(self, Elide { display: true, ..Elide::NONE })) } }
 
 /// A function value, as display shows it.
 impl fmt::Display for crate::Function { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "⟨{}⟩", self.bpl()) } }