For 2 months, as of writing, I’ve been working on Vern, an array language built around the idea of creating complexity from simplicity.

Arraylangs1 usually2 use Unicode glyphs to allow for concise code.
While this is very convenient for code size, it’s not very convenient for actually writing it, since you need to find a way to write those glyphs.

Every array language has a different way of solving this issue, and since I’ve been writing my own, I’ve been thinking about these systems quite a bit.

APL does nothing about this natively; you need copy-and-paste the symbols, use a keyboard with the symbols, or use an editor with shortcuts for it.

J, K, and Q fixes this by not having Unicode character at all.

BQN fixes this by having escapes in the online editor triggered by ‘\’, then pressing a key, creating a glyph3.

Uiua does, in my opinion, the most ergonomic of all these solutions;
a built-in formatter formats things like lasbysor into ⊣⊸⍆ (last, by, sort) or %* into ÷×, automatically finding valid operator names even if they’re slightly incomplete.
This makes it very convenient to quickly write out long lines.

Vern does a mix of the previous two solutions;
Vern has a preprocessor that converts ‘\’-based escapes into the corresponding glyphs, e.g. \%\* into ÷×, \d\.id\ into ⊓●, or +\,1969 into +₁₉₆₉;
\. is used for multi-character names, \, is used for subscript, \' is used for superscript, and just \ only escapes a single character.
The shortcuts command can be used inside of Vern’s REPL to show the glyph shortcuts:

> vern -repl
Vern 0.14.0 (end with ctrl-c, type 'help' for a list of commands)
   shortcuts

\': superscript
\,: subscript

\.multiply\, \.mult\, \* - ×
\.divide\, \.div\, \% - ÷
\.iota\, \.io\, \i - ɩ
\.shape\, \.sha\, \.sh\ - △
\.scan\, \.sca\, \.sc\, \s - ⍀
\.notequal\, \.neq\, \n - ≠
\.pop\, \.po\, \p - ⌄
\.box\, \.bx\, \b - ■
\.unbox\, \.unbx\, \.un\, \u - □
\.index\, \.ind\ - ∈
\.first\, \.fir\, \f - ⊢
\.last\, \.la\, \l - ⊣
\.decapitate\, \.decapit\, \.decap\, \.de\, \d - ⊓
\.join\, \.joi\, \.jo\, \j - ⋈
\.identity\, \.iden\, \.id\ - ●
\.modulo\, \.modu\, \.mod\, \m - ◿
\.lrot\, \.lr\ - ↺
\.rrot\, \.rr\ - ↻
\.switch\, \.swi\, \.sw\ - ⊻
\.reverse\, \.rever\, \.rev\, \r - ⧖
\.round\, \.rou\ - ⁅
\.floor\, \.flo\ - ⌊
\.ceiling\, \.ceil\ - ⌈

I choose this system because a system like Uiua’s solution is infeasible with how Vern operates (Vern is a much more flexible language compared to Uiua), and BQN’s only operated in the editor.


  1. I only (of the languages that are at least somewhat known) count APL, J, K, Q, Uiua, and BQN as ‘true’ array languages, not really for any actual reasons besides “I know them”, “I like them”, and “more similar to APL than stuff like R or Fortran”. ↩︎

  2. Exceptions are J, K, and Q. ↩︎

  3. These probably have a reasonable system of why a certain key goes to a certain glyph, but as far as I can remember, I couldn’t figure out what it was. ↩︎