BQN implementation

Makefile.impls

@@ -34,7 +34,7 @@ wasm_MODE = wasmtime
 # Implementation specific settings
 #
 
-IMPLS = ada ada.2 awk bash basic bbc-basic c c.2 chuck clojure coffee common-lisp cpp crystal cs d dart \
+IMPLS = ada ada.2 awk bash basic bbc-basic bqn c c.2 chuck clojure coffee common-lisp cpp crystal cs d dart \
 	elisp elixir elm erlang es6 factor fantom fennel forth fsharp go groovy gnu-smalltalk \
 	guile haskell haxe hy io janet java java-truffle js jq julia kotlin livescript logo lua make mal \
 	matlab miniMAL nasm nim objc objpascal ocaml perl perl6 php picolisp pike plpgsql \
@@ -110,6 +110,7 @@ awk_STEP_TO_PROG =           impls/awk/$($(1)).awk
 bash_STEP_TO_PROG =          impls/bash/$($(1)).sh
 basic_STEP_TO_PROG =         $(basic_STEP_TO_PROG_$(basic_MODE))
 bbc-basic_STEP_TO_PROG =     impls/bbc-basic/$($(1)).bas
+bqn_STEP_TO_PROG =           impls/bqn/$($(1)).bqn
 c_STEP_TO_PROG =             impls/c/$($(1))
 c.2_STEP_TO_PROG =           impls/c.2/$($(1))
 chuck_STEP_TO_PROG =         impls/chuck/$($(1)).ck

README.md

@@ -52,6 +52,7 @@ FAQ](docs/FAQ.md) where I attempt to answer some common questions.
 | [Bash 4](#bash-4) | [Joel Martin](https://github.com/kanaka)  |
 | [BASIC](#basic-c64-and-qbasic) (C64 & QBasic) | [Joel Martin](https://github.com/kanaka) |
 | [BBC BASIC V](#bbc-basic-v) | [Ben Harris](https://github.com/bjh21) |
+| [BQN](#bqn) | [Hannu Hartikainen](https://github.com/dancek)  |
 | [C](#c) | [Joel Martin](https://github.com/kanaka)  |
 | [C #2](#c2) | [Duncan Watts](https://github.com/fungiblecog)  |
 | [C++](#c-1) | [Stephen Thirlwall](https://github.com/sdt) |
@@ -289,6 +290,17 @@ Or in ARM BBC BASIC V under RISC OS 3 or later:
 *Run stepX_YYY
 ```
 
+### BQN
+
+The BQN implementation requires [CBQN](https://github.com/dzaima/CBQN) as the non-standard system values `•_while_`, `•GetLine` and `•term.OutRaw` are used. Removing them would be easy, though -- they're just for convenience and REPL usability.
+
+There are no releases of CBQN at the time of writing, but any version from mid 2022 should work. Specifically, commit `88f6585` is known to work.
+
+```
+cd impls/bqn
+./run
+```
+
 ### C
 
 The C implementation of mal requires the following libraries (lib and

impls/bqn/Dockerfile

@@ -0,0 +1,12 @@
+FROM ubuntu:22.04
+
+RUN apt-get update && \
+    apt-get install -qqy git clang build-essential python3 python-is-python3
+RUN git clone https://github.com/dzaima/CBQN.git && \
+    cd CBQN && \
+    git reset --hard 88f65850fa6ac28bc50886c5942652f21d5be924 && \
+    make && \
+    make install && \
+    ln -s bqn /usr/local/bin/BQN
+RUN mkdir /mal
+WORKDIR /mal

impls/bqn/Makefile

@@ -0,0 +1,3 @@
+all:
+
+clean:

impls/bqn/core.bqn

@@ -0,0 +1,118 @@
+⟨Atom,nil,Err,_chk,_chks⟩ ← •Import "globals.bqn"
+⟨Env⟩ ← •Import "env.bqn"
+⟨PrStr,PrStrR⟩ ← •Import "printer.bqn"
+⟨ReadStr⟩ ← •Import "reader.bqn"
+
+Q ← {∾´'"'∾𝕩∾'"'}
+J ← {0=≠𝕩 ? "" ;
+     1=≠𝕩 ? ⊑𝕩 ;
+     ∾´(⊑𝕩)∾𝕨∾𝕨J 1↓𝕩}
+E ← {𝕊 ⟨t‿a,s‿b⟩:
+      {(⊑t∊3‿4) ∧ ⊑s∊3‿4 ?
+       {(≠a)=≠b ? ∧´a E¨b ; 0};
+       (t≡s)∧a≡b} ;
+     {2<≠𝕩 ? ∧´E´˘2↕𝕩 ; 1}𝕩}
+
+ns ← ⟨
+  "+"‿{1∾+´1⊏˘>𝕩}
+  "-"‿{1∾-´1⊏˘>𝕩}
+  "*"‿{1∾×´1⊏˘>𝕩}
+  "/"‿{1∾⌊∘÷´1⊏˘>𝕩}
+
+  "="‿{7∾E𝕩}
+  "<"‿{7∾∧´<´˘2↕1⊸⊑¨𝕩}
+  "<="‿{7∾∧´≤´˘2↕1⊸⊑¨𝕩}
+  ">"‿{7∾∧´>´˘2↕1⊸⊑¨𝕩}
+  ">="‿{7∾∧´≥´˘2↕1⊸⊑¨𝕩}
+
+  "empty?"‿{7∾0=≠1⊑⊑𝕩}
+  "count"‿{1∾≠1⊑⊑𝕩}
+
+  "bqn-show"‿{•Show ⊑ 𝕩}
+  "pr-str"‿{2∾<" "J PrStrR¨𝕩}
+  "str"‿{2∾<""J PrStr¨𝕩}
+  "prn"‿{•Out " "J PrStrR¨𝕩 ⋄ nil}
+  "println"‿{•Out " "J PrStr¨𝕩 ⋄ nil}
+
+  "read-string"‿{ReadStr 1⊑⊑𝕩}
+  "slurp"‿{2∾<•FChars 1⊑⊑𝕩}
+
+  "atom"‿{11∾Atom ⊑𝕩}
+  "atom?"‿{7∾11=⊑⊑𝕩}
+  "deref"‿{𝕊 ⟨11‿a⟩: a.Deref@; Err "deref: not an atom"}
+  "reset!"‿{
+    𝕊 ⟨11‿a,v⟩: a.Reset v;
+    Err "reset!: not an atom"}
+  "swap!"‿{
+    ⟨t‿a,fn⟩ ← 2↑𝕩
+    args ← (<a.Deref@) ∾ 2↓𝕩
+    f ← {9‿f: f; 10‿x‿y‿z‿f: f}fn
+    a.Reset F args}
+
+  "cons"‿{𝕊 x‿⟨t,xs⟩: 3∾<(<x)∾xs ; Err "cons"}
+  "concat"‿{𝕊 ⟨⟩:3‿⟨⟩; 3∾<∾´1⊸⊑¨𝕩}
+
+  "nth"‿{𝕊 ⟨t‿xs,1‿n⟩: {n<≠xs ? n⊑xs ; Err "out of bounds"}}
+  "first"‿{S ⟨t‿xs⟩: {0<≠xs ? ⊑xs ; nil}; nil}
+  "rest"‿{𝕊 ⟨t‿⟨⟩⟩: 3‿⟨⟩; 𝕊 ⟨t‿xs⟩: 3∾<1↓xs; 3‿⟨⟩}
+
+  "throw"‿{𝕊 ⟨x⟩: ¯1‿x}
+
+  "apply"‿{𝕊
+    fn ← {9‿f:f; 10‿b‿a‿e‿f: f}⊑𝕩
+    args ← (¯1↓1↓𝕩)∾1⊑¯1⊑𝕩
+    Fn _chks args}
+  "map"‿{𝕊
+    fn ← {9‿f:f; 10‿b‿a‿e‿f: f}⊑𝕩
+    {3∾<𝕩}_chks{Fn ⟨𝕩⟩}¨ 1⊑1⊑𝕩}
+
+  "nil?"‿{𝕊 ⟨8‿⟨⟩⟩: 7‿1; 7‿0}
+  "true?"‿{𝕊 ⟨7‿1⟩: 7‿1; 7‿0}
+  "false?"‿{𝕊 ⟨7‿0⟩: 7‿1; 7‿0}
+  "symbol?"‿{𝕊 ⟨0‿x⟩: 7‿1; 7‿0}
+  "keyword?"‿{𝕊 ⟨6‿x⟩: 7‿1; 7‿0}
+  "vector?"‿{𝕊 ⟨4‿x⟩: 7‿1; 7‿0}
+  "list?"‿{𝕊 ⟨3‿x⟩: 7‿1; 7‿0}
+  "map?"‿{𝕊 ⟨5‿x⟩: 7‿1; 7‿0}
+  "sequential?"‿{𝕊 ⟨3‿x⟩: 7‿1; 𝕊 ⟨4‿x⟩: 7‿1; 7‿0}
+  "string?"‿{𝕊 ⟨2‿x⟩: 7‿1; 7‿0}
+  "number?"‿{𝕊 ⟨1‿x⟩: 7‿1; 7‿0}
+  "fn?"‿{7∾{9:1;10:1;0}⊑⊑𝕩}
+
+  "symbol"‿{0∾<1⊑⊑𝕩}
+  "keyword"‿{𝕊 ⟨6‿kw⟩: 6‿kw;
+             𝕊 ⟨2‿s⟩: 6∾<':'∾s}
+  "list"‿{3‿𝕩}
+  "vector"‿{4‿𝕩}
+  "hash-map"‿{5‿𝕩}
+  "vec"‿{𝕊 ⟨4‿x⟩: 4‿x; 𝕊 ⟨3‿x⟩: 4‿x}
+
+  "keys"‿{𝕊 ⟨5‿xs⟩: 3∾<⥊⊏˘∘‿2⥊xs}
+  "vals"‿{𝕊 ⟨5‿xs⟩: 3∾<⥊1⊏˘∘‿2⥊xs}
+  "get"‿{𝕊 ⟨5‿xs,k⟩: 1⊑@‿nil∾˜⥊(k⊸≡˘⊑˘)⊸/∘‿2⥊xs; nil}
+  "contains?"‿{𝕊 ⟨5‿xs,k⟩: 7∾×+´k⊸≡˘⊑˘∘‿2⥊xs}
+  "dissoc"‿{𝕊 ⟨x⟩: x;
+    ⟨t‿xs,k⟩ ← 2↑𝕩
+    𝕊 (2↓𝕩)∾˜<5∾<⥊(k⊸≢˘⊑˘)⊸/∘‿2⥊xs}
+  "assoc"‿{𝕊 ⟨x⟩: x;
+    ⟨t‿xs,k,v⟩ ← 3↑𝕩
+    𝕊 (3↓𝕩)∾˜<5∾<k‿v∾˜⥊(k⊸≢˘⊑˘)⊸/∘‿2⥊xs}
+
+  "readline"‿{𝕊 ⟨2‿s⟩:
+    •term.OutRaw s
+    in ← •GetLine 0
+    {in≡@ ? nil ; 2‿in}}
+
+  "time-ms"‿{𝕊⋄1∾⌊1000וMonoTime@}
+
+  "meta"‿(¯1‿"NYI")
+  "with-meta"‿(¯1‿"NYI")
+  "seq"‿(¯1‿"NYI")
+  "conj"‿(¯1‿"NYI")
+⟩
+
+core ⇐ Env@
+{𝕊 kw‿f: core.Set kw‿(9‿f)}¨ns
+
+core.Set "*host-language*"‿(2‿"BQN")
+core.Set "*ARGV*"‿⟨3,⟨⟩⟩

impls/bqn/env.bqn

@@ -0,0 +1,14 @@
+⟨Err⟩ ← •Import "globals.bqn"
+
+Env ⇐ {𝕊 outer:
+  d ⇐ ↕0‿2
+  Set ⇐ {𝕊 k‿v:
+    d ↩ k‿v∾((<k)≢˘⊏˘)⊸/d
+  }
+  Get ⇐ {𝕊 k: {
+    i ← ⊑(⊏˘d)⊐<k
+    i<⊑≢d ? i‿1⊑d ;
+    outer≠@ ? outer.Get k ;
+    Err "'"∾k∾"' not found"
+  }}
+}

impls/bqn/globals.bqn

@@ -0,0 +1,9 @@
+nil ⇐ 8‿⟨⟩
+
+Atom⇐ {𝕊 v:
+  Reset ⇐ {v↩𝕩}
+  Deref ⇐ {𝕊⋄v}
+}
+Err ⇐ {¯1‿⟨2,𝕩⟩}
+_chk ⇐ {¯1=⊑⎊0𝕩 ? 𝕩 ; 𝕨𝔽𝕩}
+_chks ⇐ {⊑¯1∊⊑¨𝕩 ? (⊑(⊑¨𝕩)⊐¯1)⊑𝕩 ; 𝕨𝔽𝕩}

impls/bqn/printer.bqn

@@ -0,0 +1,31 @@
+Lst ← {0=≠𝕩 ? "" ; {𝕨∾" "∾𝕩}´(𝕨⊸P¨𝕩)}
+P ← {
+  r 𝕊 ¯1‿x: "ERROR: "∾r𝕊x;
+  r 𝕊 12‿x: "#macro";
+  r 𝕊 11‿a: "(atom "∾(r P a.Deref@)∾")";
+  r 𝕊 10‿x‿y‿z‿f: "#function";
+  r 𝕊 9‿x: "#function";
+  r 𝕊 8‿x: "nil";
+  r 𝕊 7‿0: "false";
+  r 𝕊 7‿1: "true";
+  r 𝕊 6‿kw: kw;
+  r 𝕊 5‿l: "{"∾(r Lst l)∾"}";
+  r 𝕊 4‿l: "["∾(r Lst l)∾"]";
+  r 𝕊 3‿l: "("∾(r Lst l)∾")";
+  0 𝕊 2‿s: s;
+  1 𝕊 2‿s:
+    ∾´{
+      𝕊 '"': "\""";
+      𝕊 '
+': "\n";
+      𝕊 '\': "\\";
+      𝕊 @: """";
+      ""∾𝕩
+    }¨(@∾s∾@);
+  r 𝕊 1‿n: {n<0?"-";""}∾•Fmt |n;
+  r 𝕊 0‿x: x;
+  "ERROR printing: "∾(@+10)∾•Fmt 𝕩
+}
+
+{PrStr  ⇐ 0⊸P
+ PrStrR ⇐ 1⊸P}

impls/bqn/reader.bqn

@@ -0,0 +1,129 @@
+⟨nil⟩ ← •Import "globals.bqn"
+# Types:
+# ¯1 error
+# 0 symbol
+# 1 int
+# 2 string
+# 3 list
+# 4 vector
+# 5 hashmap
+# 6 keyword
+# 7 boolean
+# 8 nil
+# 9 function
+# 10 fn*
+# 11 atom
+# 12 macro
+
+Reader ← {𝕊 tokens:
+  r ← {
+    ts ← tokens
+    Peek ⇐ {𝕊 ⋄ 0=≠ts ? @; ⊑ts}
+    Next ⇐ {𝕊
+      t ← r.Peek@
+      ts ↩ 1↓ts
+      t
+    }
+  }
+}
+
+T ← {𝕊 s:
+  v←⟨⟩
+  {𝕊
+    @=⊑s ? •Exit 0 ;
+    '@'=⊑s ? v∾↩<"@" ⋄ s↩1↓s ;
+    "~@"≡2↑s ? v∾↩<"~@" ⋄ s↩2↓s ;
+    ⊑(⊑s)∊" ,"∾@+10 ? s↩1↓s ;
+    ⊑(⊑s)∊"[]{}()'`~" ? v∾↩<≍⊑s ⋄ s↩1↓s ;
+    ';'=⊑s ?
+      o←⟨⟩
+      {𝕊
+        o ∾↩ ⊑s
+        s ↩ 1↓s
+        {0=≠s ? 0 ; (⊑s) ≠ @+10}
+      } •_while_⊢1
+      v∾↩<o ;
+    """"≡s ? •Out "unbalanced quotes: """ ⋄ s↩⟨⟩;
+    '"'=⊑s ?
+      o‿p‿r ← """"‿1‿1
+      {𝕊
+        s ↩ 1↓s
+        c ← ⊑s
+        o ∾↩ c
+        q ← p∧c='"'
+        {p ? p↩c≠'\' ; p↩1}
+        {q?@;r ↩ 1<≠s}
+        r∧¬q
+      } •_while_⊢1
+      {r?@;•Out "unbalanced quotes: "∾o}
+      v∾↩<o ⋄ s↩1↓s;
+    o←⟨⟩
+    {𝕊
+      o ∾↩ ⊑s
+      s ↩ 1↓s
+      {0=≠s ? 0 ; ¬⊑(⊑s)∊"[]{}()'""`~,; "∾@+10}
+    } •_while_⊢1
+    v∾↩<o
+  }•_while_{𝕊 ⋄ 0≠≠s}@
+  v
+}
+
+# Thanks to Marshall for writing this version of readString and
+# suhr for suggesting the `out` value of Ctrl-* characters! (My
+# version was verbose functional code while this is array style.)
+readString ← {
+  in  ← "abefnrtv"
+  out ← "GH[LJMIK"-64
+  diff← (out-in)∾0
+  {
+    m ← » bs ← <`𝕩='\'
+    (¬bs) / (diff⊏˜in⊸⊐)⊸+⌾(m⊸/) 𝕩
+  }
+}
+
+Int ← {10⊸×⊸+˜´'0'-˜⌽𝕩}
+nums ← "0123456789"
+Atom ← {
+  𝕊 "true": 7‿1 ;
+  𝕊 "false": 7‿0 ;
+  𝕊 "nil": nil ;
+  𝕊 a: {'"': 2∾<ReadString 1↓¯1↓a ;
+   ':': 6‿a ;
+   ';': @ ;
+   ⊑𝕩∊nums ? 1∾Int a ;
+   (∧´(1↓a)∊nums)∧(𝕩='-')∧1<≠a ? 1∾-Int 1↓a ;
+   0‿a }⊑a
+}
+
+ReadList ← {𝕊 r‿t‿e:
+  l←⟨⟩
+  {𝕊
+    {@: t ↩ ¯1 ⋄ l ↩ "unbalanced parens" ⋄ 0;
+     𝕩≡e ? r.Next@ ⋄ 0;
+     v ← ReadForm r
+     {v≡@ ? @; l∾↩<v}
+     1
+    }r.Peek@
+  }•_while_⊢1
+  t‿l
+}
+
+ReadForm ← {𝕊 r:
+  {"(": ReadList r‿3‿")" ;
+   "[": ReadList r‿4‿"]" ;
+   "{": ReadList r‿5‿"}" ;
+   "@": 3‿⟨0‿"deref", ReadForm r⟩;
+   "'": 3‿⟨0‿"quote", ReadForm r⟩;
+   "`": 3‿⟨0‿"quasiquote", ReadForm r⟩;
+   "~": 3‿⟨0‿"unquote", ReadForm r⟩;
+   "~@": 3‿⟨0‿"splice-unquote", ReadForm r⟩;
+   Atom 𝕩
+  }r.Next@
+}
+
+{
+  Tokenize ⇐ T
+  ReadStr ⇐ {
+    v ← ReadForm Reader Tokenize 𝕩
+    v≢@ ? v ; nil}
+}

impls/bqn/run

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec BQN $(dirname $0)/${STEP:-stepA_mal}.bqn "${@}"

impls/bqn/step0_repl.bqn

@@ -0,0 +1,11 @@
+READ ← ⊢
+EVAL ← ⊢
+PRINT ← ⊢
+Rep ← PRINT∘EVAL∘READ
+
+{
+  •Out "user> "
+  line ← •GetLine 0
+  •Out Rep line
+  𝕊𝕩
+} @

impls/bqn/step1_read_print.bqn

@@ -0,0 +1,14 @@
+⟨ReadStr⟩ ← •Import "reader.bqn"
+⟨PrStrR⟩ ← •Import "printer.bqn"
+
+READ ← ReadStr
+EVAL ← ⊢
+PRINT ← PrStrR
+Rep ← PRINT∘EVAL∘READ
+
+{
+  •Out "user> "
+  line ← •GetLine 0
+  •Out Rep line
+  𝕊𝕩
+}@