basedpl 0.1.28 → 0.1.31

package/README.md

@@ -1,242 +1,60 @@
-# BasedPL
+# basedpl
 
+This package runs BasedPL (BPL) in a web page. BPL is an array language derived from APL, with ideas from J and BQN. The package holds the BPL interpreter compiled to WebAssembly, a language bar for typing BPL's glyphs, and a TextMate grammar for highlighting BPL code. The [BPL documentation](https://answerdotai.github.io/basedpl/) covers the language. The [playground](https://answerdotai.github.io/basedpl/playground.html) runs BPL in the browser with this package.
 
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+## Load the package
 
-BasedPL, the Based-array Programming Language, is an array language derived from APL, with ideas from J and BQN. Its notation aims to be simple and consistent. Most of this documentation calls it BPL. BPL is written in Rust and comes as a native executable, a Jupyter kernel and a Python API.
+jsDelivr serves every file in the package. An unversioned URL, such as `https://cdn.jsdelivr.net/npm/basedpl/basedpl_wasm.js`, gives the latest release. To keep one release, put its version in the URL: `https://cdn.jsdelivr.net/npm/basedpl@<version>/basedpl_wasm.js`. To install the package instead, run `npm install basedpl`.
 
-LLMs: read [llms.txt](https://answerdotai.github.io/basedpl/llms.txt) first. It is the primary reference index and concise overview.
+## Run BPL
 
-## Install and try it
+```js
+import init, { Session, configure } from 'https://cdn.jsdelivr.net/npm/basedpl/basedpl_wasm.js';
 
-``` sh
-pip install basedpl
-bpl
+await init();
+configure(location.href, message => console.error(message));
+const session = new Session();
+const error = session.run('avg←+/÷≢ ⋄ avg 2 4 9', output => console.log(output.data['text/plain']));
 ```
 
-Each release also has a standalone `bpl` that needs no Python, for macOS on Apple silicon and for Linux on x86-64 and arm64. On a Mac:
+This logs `5`, and `error` is `null`.
 
-``` sh
-curl -Lo bpl https://github.com/AnswerDotAI/basedpl/releases/latest/download/bpl-macos-arm64
-chmod +x bpl
-```
-
-On Linux, download `bpl-linux-x86_64` or `bpl-linux-arm64` instead.
-
-At the prompt, define a mean and apply it:
-
-``` bpl
-avg←+/÷≢
-avg 2 4 9
-```
-
-    5
-
-Use `bpl -e 'avg←+/÷≢ ⋄ avg 2 4 9'` for a shell command. The [command-line guide](https://answerdotai.github.io/basedpl/cli.html) covers source files and pipes.
-
-## Interactive use
-
-In the REPL, type a backtick followed by a glyph name. For example, `` `iota `` becomes `⍳` when you press Tab or type a non-letter. Abbreviations and Alt-key shortcuts are available. `]help +` shows help for `+`. [`•prefs`](https://answerdotai.github.io/basedpl/system-functions.html#prefs) changes display settings, such as boxes and how much of a large array shows. See [REPL](https://answerdotai.github.io/basedpl/repl.html) and the [glyph reference](https://answerdotai.github.io/basedpl/glyphs.html), which lists each glyph’s key.
-
-In Jupyter, select the installed **BasedPL** kernel. Cells share definitions and support completion, Shift-Tab help and interruption. You can also use `%%bpl` cells in a Python notebook. See [Using BPL notebooks](https://answerdotai.github.io/basedpl/notebooks.html).
-
-## New to APL?
-
-APL is a language built around operations on whole arrays and notation for combining functions. Here is a taste of that style in BPL.
-
-Numbers separated by spaces form a vector. Arithmetic applies to every element:
-
-``` bpl
-10+1 2 3
-```
-
-    11 12 13
-
-Operators modify or combine functions. Reduce (`/`) turns addition into summation. `⍳10` generates 0…9:
-
-``` bpl
-+/⍳10
-```
-
-    45
-
-Functions can also be combined without naming their arguments. In `avg←+/÷≢`, sum (`+/`) divided by tally (`≢`) defines the mean:
-
-``` bpl
-avg 1 2 3 4
-```
-
-    2.5
-
-To see how these ideas express an algorithm, start from “a prime has exactly two positive divisors”. Form all remainders of 1 to 50 (`|⊗⍨1+⍳50`), count the zeros down each column (`+⌿0=`), and find the positions (`⍸`) whose count is two. Positions count from 0. `1+` turns each position back into its number:
-
-``` bpl
-1+⍸2=+⌿0=|⊗⍨1+⍳50
-```
-
-    2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
-
-[Getting started](https://answerdotai.github.io/basedpl/getting-started.html#example-algorithms) builds a primes function from the same divisor count, step by step, and displays the divisibility matrix along the way.
-
-## What’s distinctive?
-
-For APL users, some key differences are:
-
-- [Based arrays](https://answerdotai.github.io/basedpl/arrays.html), as in BQN: numbers, characters and functions are atoms; enclosure always adds a layer.
-- **Vectors in brackets, and grouping by spaces.** `[a b c]` is a vector, and `a+b × c+d` is `(a+b)×(c+d)`. A run that ends in a function is a train. For example, `+/÷≢ x` is the mean of `x`, and `2×` doubles its argument. `0⌷v` and `v₀` both select the first item of `v`.
-- **Leading-axis broadcasting**, including expansion of length-1 axes, plus string keys and names on axes.
-- **Exact integers and rationals** alongside approximate real and complex numbers.
-- Dfns, trains and operators, with additions such as Under, iteration histories, windows and function arrays.
-
-Positions and axes count from 0, as in BQN and Python. Approximate comparisons use tolerance `1E¯14`. See the [language principles](https://answerdotai.github.io/basedpl/principles.html) for why BPL works this way, the [glyph reference](https://answerdotai.github.io/basedpl/glyphs.html) for Dyalog differences and [Arrays](https://answerdotai.github.io/basedpl/arrays.html) for the array model.
-
-### Numbers
-
-Bare numbers are approximate. Use `ₓ` for exact integers and `r` for exact fractions:
-
-``` bpl
-1r3+1r6
-```
-
-    1ᵣ2
-
-Complex numbers use `j` between real and imaginary parts. Functions such as square root extend into the complex domain:
-
-``` bpl
-√¯4
-```
-
-    0ⱼ2
-
-See [Numbers](https://answerdotai.github.io/basedpl/numbers.html) for conversion and mixed arithmetic.
-
-### Array literals and broadcasting
-
-Write matrix rows directly in an array literal. Leading-axis agreement lets a vector supply one offset per row:
+- `init()` fetches the module from beside the glue.
+- `configure(base, panic)` sets the URL that relative file reads resolve against, and the function that receives a panic's message. After a panic, the module can't run more code.
+- `session.run(code, output)` runs `code`, then returns `null` or the error. The error is an object with `kind`, `message` and `display`. `display` holds the error as BPL shows it. A session keeps its names from one `run` to the next.
+- `output` receives each output as the program produces it, as `{kind, data}`. `kind` is `"display"` for a displayed value, `"explicit"` for a value assigned to `⎕`, or `"text"` for text written with `"-" •nput`. Display and explicit outputs each end a line. Text output doesn't.
 
-``` bpl
-m←[1 2 3
-   4 5 6]
-m+10 20
-```
-
-    11 12 13
-    24 25 26
-
-See [array notation](https://answerdotai.github.io/basedpl/glyphs/brackets.html) and [broadcasting](https://answerdotai.github.io/basedpl/evaluation.html#agreement-and-pervasion).
-
-### Keys and named axes
-
-Axes can have names, and positions along them can have string keys. Describe the axes once, then select by key or reduce by axis name:
-
-``` bpl
-axes←["city":["NY" "LA"] "month":["Jan" "Feb" "Mar"]]
-sales←axes:[10 20 30 ⋄ 40 50 60]
-"LA" "Feb"⌷sales
-+/⍠"month" sales
-```
-
-    50
-
-    ["city":2]⍴["NY":60 "LA":150]
-
-Keys and names travel with axes through operations such as transpose. Arithmetic aligns matching names and keys. See [Axis keys](https://answerdotai.github.io/basedpl/keyed.html).
-
-### Function operators
-
-A vector of counts keeps the history: one state for each count, where count 0 is the initial value. Here, double up to four times:
+`data` maps MIME types to text, or to a `Uint8Array` for a binary type:
 
-``` bpl
-2×⍣(⍳5) 1
-```
-
-    1 2 4 8 16
-
-Under (`⌾`) transforms the argument, applies a function, then reverses the transformation. Scale by ten, floor, and scale back to round down to tenths:
-
-``` bpl
-⌊⌾ 10× 1.25 2.78
-```
-
-    1.2 2.7
-
-Explore [iteration and inverses](https://answerdotai.github.io/basedpl/glyphs/power.html), [Under](https://answerdotai.github.io/basedpl/glyphs/under.html), [windows](https://answerdotai.github.io/basedpl/glyphs/windows.html) and [function selection](https://answerdotai.github.io/basedpl/glyphs/agenda.html).
-
-### Mathematical tools
-
-[Primes](https://answerdotai.github.io/basedpl/glyphs/prime.html) and [factorisation](https://answerdotai.github.io/basedpl/glyphs/factor.html) are built in:
-
-``` bpl
-⨸360ₓ
-```
+- `text/plain`: the output as text.
+- `text/html`: markup from element functions.
+- `image/svg+xml`: markup from `•svg` and `•plot`.
+- `image/x-rgba;width=N`: RGBA pixels from `•image`, `N` pixels wide. `new ImageData(new Uint8ClampedArray(bytes.buffer), N)` makes a canvas image from them.
+- `image/png` and `image/jpeg`: encoded images.
 
-    [2 2 2 3 3 5]ₓ
+`run` returns only when the code finishes. To keep the page responsive, run BPL in a Web Worker. The playground's [`worker.js`](https://github.com/AnswerDotAI/basedpl/blob/main/nbs/playground/worker.js) and [`page.js`](https://github.com/AnswerDotAI/basedpl/blob/main/nbs/playground/page.js) show a complete page.
 
-[Polynomials](https://answerdotai.github.io/basedpl/glyphs/polynomial.html) support coefficients, roots and evaluation. Polynomial functions can be [differentiated](https://answerdotai.github.io/basedpl/glyphs/derivative.html): for f(x) = 1 + 2x + 3x², f′(2) = 14.
-
-``` bpl
-f←[1 2 3]ₓ⌻ ⋄ f∂2ₓ
-```
-
-    14ₓ
-
-[Probability distributions](https://answerdotai.github.io/basedpl/distributions.html) provide sampling, density, CDF and quantiles. Two fair coin tosses give these probabilities for 0, 1 and 2 heads:
-
-``` bpl
-coin←2 0.5 •distribution "binomial"
-coin.density 0 1 2
-```
-
-    0.25 0.5 0.25
-
-[Matrix division](https://answerdotai.github.io/basedpl/glyphs/domino.html) handles linear systems and least squares.
-
-### Data and text
-
-JSON objects become keyed arrays, with dot access to their fields:
-
-``` bpl
-order←•json "{""price"":10.5,""qty"":2}"
-order.price×order.qty
-```
-
-    21
-
-CSV headers likewise name column vectors. [Files, CSV and JSON](https://answerdotai.github.io/basedpl/data.html) covers reading, transforming and writing data. [Regex](https://answerdotai.github.io/basedpl/regex.html) supplies matching, captures and replacement through Rust’s regex engine.
-
-### Drawing
-
-`•plot` draws charts from arrays. Keys label the axes and name the lines. See [Plots](https://answerdotai.github.io/basedpl/plot.html).
-
-``` bpl
-["legend":"end"]•plot sales
-```
-
-![](index_files/figure-commonmark/cell-17-output-1.svg)
-
-Build SVG from element functions and keyed attributes. Notebooks display the picture directly. The same element trees serialize to XML. See [XML and SVG](https://answerdotai.github.io/basedpl/xml.html).
-
-``` bpl
-circle←•element "circle"
-text←•element "text"
-c←["cx":50 "cy":40 "r":25 "fill":"orange"]circle ""
-t←["x":50 "y":85 "text-anchor":"middle"]text "Hello, SVG"
-["width":240 "height":240]•svg [c t]
-```
+## Differences from native BPL
 
-![](index_files/figure-commonmark/cell-18-output-1.svg)
+- `•readdir`, `•metadata`, `•copy`, `•rename`, `•remove`, `•mkdir`, `•path` and `•delay` don't exist. `•nput` writes only to `"-"`.
+- File reads and `•fetch` are synchronous `XMLHttpRequest`s, relative to the URL given to `configure`.
+- `•r` uses JavaScript's `RegExp`, with its syntax and replacement templates.
+- `•date⁻¹` has no `locale` option.
+- Function calls nest at most 410 deep. A deeper call is a `LIMIT` error.
 
-## Python
+## Language bar
 
-BPL functions are Python callables:
+`lb.js` adds a bar of BPL's glyphs to the page. Clicking a glyph types it into the editor used last. In a textarea marked with `data-bpl`, or a Monaco editor whose language is `bpl`, a backtick followed by a glyph's name also types the glyph, as in the BPL REPL. `lb.js` and `input.js` are scripts whose value is a function. The bar needs the glyph rows from `symbols()` and the key layout from `layout.json`:
 
-``` python
-from basedpl import fn
+```js
+import init, { symbols } from 'https://cdn.jsdelivr.net/npm/basedpl/basedpl_wasm.js';
 
-mean = fn('+/÷≢')
-mean([1, 2, 3])
+const text = name => fetch(`https://cdn.jsdelivr.net/npm/basedpl/${name}`).then(r => r.text());
+const [lb, input, layout] = await Promise.all(['lb.js', 'input.js', 'layout.json'].map(text));
+await init();
+(0, eval)(lb)(JSON.parse(symbols()), (0, eval)(input), JSON.parse(layout));
 ```
 
-Arrays have `.py`, `.np` and `.df` conversions for Python values, NumPy and pandas. Functions also have Python names and composition operators. See the [Python tutorial](https://answerdotai.github.io/basedpl/python.html).
+## Highlighting
 
-For other frontends, the [process interfaces](https://answerdotai.github.io/basedpl/processes.html) provide JSON messages and interruptible workers. The [BPL library](https://github.com/AnswerDotAI/basedpl/tree/main/lib) contains more algorithms, codecs, interpreters and puzzles.
+`bpl.tmLanguage.json` is a TextMate grammar for BPL, with the scope name `source.bpl`. Shiki and editors that read TextMate grammars use it to highlight BPL code.

package/basedpl_wasm.js

@@ -16,29 +16,17 @@ export class Session {
         return this;
     }
     /**
-     * The JSON reply to a JSON request: `{"error": …}`, with `null` when the request succeeds. Each output goes to `output`, as JSON,
-     * while the program runs. The reply has no value: a page shows the output, and a value that holds functions has no JSON form.
-     * @param {string} request
+     * Runs `code`, passing each output to `output` as the program produces it, including any result it displays. Returns the error as
+     * an object, or `null`.
+     * @param {string} code
      * @param {Function} output
-     * @returns {string}
+     * @returns {any}
      */
-    request(request, output) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.session_request(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(output));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
-        }
+    run(code, output) {
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.session_run(this.__wbg_ptr, ptr0, len0, addHeapObject(output));
+        return takeObject(ret);
     }
 }
 if (Symbol.dispose) Session.prototype[Symbol.dispose] = Session.prototype.free;
@@ -77,6 +65,13 @@ export function symbols() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'function';
             return ret;
@@ -268,6 +263,10 @@ function __wbg_get_imports() {
             const ret = new Date(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_new_617a8cdb8bb1130e: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
         __wbg_new_a217df4351db4b9b: function() { return handleError(function (arg0, arg1) {
             const ret = new OffscreenCanvas(arg0 >>> 0, arg1 >>> 0);
             return addHeapObject(ret);
@@ -276,6 +275,10 @@ function __wbg_get_imports() {
             const ret = new XMLHttpRequest();
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_with_base_29cdb449ce79d2d5: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = new URL(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
             return addHeapObject(ret);
@@ -307,6 +310,10 @@ function __wbg_get_imports() {
         __wbg_open_f0c8628338345808: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
         }, arguments); },
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
             const ret = getObject(arg0).performance;
             return addHeapObject(ret);
@@ -331,6 +338,10 @@ function __wbg_get_imports() {
         __wbg_setRequestHeader_733b74e99bf9b791: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
         __wbg_set_font_1f60a05a2544a2ff: function(arg0, arg1, arg2) {
             getObject(arg0).font = getStringFromWasm0(arg1, arg2);
         },
@@ -406,6 +417,71 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function dropObject(idx) {
     if (idx < 1028) return;
     heap[idx] = heap_next;

package/bpl.tmLanguage.json

@@ -0,0 +1,108 @@
+{
+  "name": "bpl",
+  "scopeName": "source.bpl",
+  "fileTypes": [
+    "bpl"
+  ],
+  "patterns": [
+    {
+      "begin": "⍝",
+      "beginCaptures": {
+        "0": {
+          "name": "comment.line.bpl"
+        }
+      },
+      "end": "$",
+      "contentName": "comment.line.bpl",
+      "patterns": [],
+      "applyEndPatternLast": true
+    },
+    {
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "string.quoted.double.bpl"
+        }
+      },
+      "end": "\"|$",
+      "contentName": "string.quoted.double.bpl",
+      "patterns": [
+        {
+          "match": "\"\"",
+          "name": "string.quoted.double.bpl"
+        }
+      ],
+      "applyEndPatternLast": true,
+      "endCaptures": {
+        "0": {
+          "name": "string.quoted.double.bpl"
+        }
+      }
+    },
+    {
+      "match": "'.?'",
+      "name": "string.quoted.single.bpl"
+    },
+    {
+      "match": "[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*(\\.[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*)*",
+      "name": "source.bpl"
+    },
+    {
+      "match": "•[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*",
+      "name": "support.function.system.bpl"
+    },
+    {
+      "match": "¯?∞|¯?(\\d+(\\.\\d+)?|\\.\\d+)([eEₑ]¯?\\d+)?([jJⱼ]¯?(\\d+(\\.\\d+)?|\\.\\d+)([eEₑ]¯?\\d+)?|ₓ|[rᵣ]¯?\\d+)?",
+      "name": "constant.numeric.bpl"
+    },
+    {
+      "match": "⍬ₓ?",
+      "name": "constant.numeric.bpl"
+    },
+    {
+      "match": "\\$[tfn]",
+      "name": "constant.numeric.bpl"
+    },
+    {
+      "match": "\\$[ad]",
+      "name": "string.quoted.double.bpl"
+    },
+    {
+      "begin": "[\\])](?=ₓ)",
+      "beginCaptures": {
+        "0": {
+          "name": "source.bpl"
+        }
+      },
+      "end": "[ₓ]|$",
+      "contentName": "constant.numeric.bpl",
+      "patterns": [],
+      "applyEndPatternLast": true,
+      "endCaptures": {
+        "0": {
+          "name": "constant.numeric.bpl"
+        }
+      }
+    },
+    {
+      "match": "[\\+\\-×÷⌈⌊\\|\\*⍟○π√!∧∨⊼⊽\\~=≠<≤>≥⍳:⍴≢≡,⍪⊂⊃⊆∊∪∩⍋⍒↑↓⌽⊖⍉⊤⊥⍎⍕⌷⌹\\#↕⍭⨸⌻⍸⍷⊢⊣¿]",
+      "name": "support.function.bpl"
+    },
+    {
+      "match": "[¨⍨⊗⌸∂/⌿\\\\⍀⁰¹²³⁴⁵⁶⁷⁸⁹⁻ᵀᵘ]",
+      "name": "keyword.operator.monadic.bpl"
+    },
+    {
+      "match": "[↣⍤∘⍠⍥↢\\.⍣⇄⊘⌾⍚@⌺]",
+      "name": "keyword.operator.dyadic.bpl"
+    },
+    {
+      "match": "[⍺⍵⍶⍹∇⍢]",
+      "name": "variable.parameter.bpl"
+    },
+    {
+      "match": "[←→⎕⋄\\?₀₁₂₃₄₅₆₇₈₉₋]",
+      "name": "keyword.control.bpl"
+    }
+  ]
+}

package/input.js

@@ -73,8 +73,11 @@
                 if (python && c === '\\') i++;
                 else if (text.startsWith(quote, i)) { i += quote.length - 1; quote = ''; }
             } else if (c === "'" && !python) {
-                if (i + 2 >= text.length) return false;
-                i += 2;
+                if (text.startsWith("''", i) && !text.startsWith("'''", i)) i++;
+                else {
+                    if (i + 2 >= text.length) return false;
+                    i += 2;
+                }
             } else if (c === "'" || c === '"') {
                 quote = python && text.startsWith(c.repeat(3), i) ? c.repeat(3) : c;
                 i += quote.length - 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basedpl",
-  "version": "0.1.28",
+  "version": "0.1.31",
   "description": "BasedPL, the Based-array Programming Language, is an APL-derived array language, borrowing ideas from J and BQN, with an emphasis on simple, consistent notation.",
   "license": "Apache-2.0",
   "repository": {