BQN

BQN
Developer	Marshall Lochbaum
Released	2020
Latest release	2022 (unversioned)
Array model	based
Index origin	0
Function styles	block (like dfns), tacit
Numeric types	64-bit float
Unicode support	full
File extensions	.bqn
Implementation languages	BQN with JavaScript, C, or others
Source code	GitHub
Platforms	x86, ARM, in-browser, Node.js
License	ISC
Website	mlochbaum.github.io/BQN
Forum	#bqn:matrix.org
Documentation	Documentation
Run online	BQNPAD
Influenced by	J, A+, Dyalog APL, Co-dfns, APL\iv, JavaScript

BQN is an APL-family language designed primarily by Marshall Lochbaum. Although it maintains the concept of array-driven computing and much of APL's array functionality, BQN discards all compatibility with other array languages and changes many fundamental concepts. It uses the based array model with dedicated array notation, distinguishes between data types and expression roles to give the language a context-free grammar with first-class functions, and uses a new set of glyphs with different primitive pairings. The language uses the leading axis model and tacit programming as core paradigms. Its implementation is largely self-hosted, with an array-based compiler like Co-dfns.

Implementations

BQN has several implementations, with all complete ones based on self-hosted sources, which are compiled to bytecode and included as literal arrays or similar in the implementation's source. CBQN, developed by dzaima in C, is the primary implementation with the best performance. A JavaScript version can be run online. It's slower than CBQN compiled to Wasm, but easier to connect with browser functionality.

The Singeli language was developed in order to implement BQN more effectively. CBQN uses Singeli for primitive code that uses vector instructions, and can be built with or without these optimized implementations. The Singeli implementation is written in BQN and currently targets C.

dzaima/BQN

Now largely replaced by CBQN, dzaima/BQN is dzaima's independent implementation in Java, based on dzaima/APL. While dzaima/APL adds significant new functionality and is different from any other APL, dzaima/BQN follows the BQN specification closely and sometimes extends it with system functions. It has often been the first implementation to support new functionality, particularly syntax such as block headers, and was the fastest implementation before CBQN was created. It introduced the bytecode format now shared with self-hosted BQN, and was used for development and bootstrapping.

Primitives

Functions

Glyph	Monadic	Dyadic
+	Conjugate	Add
-	Negate	Subtract
×	Sign	Multiply
÷	Reciprocal	Divide
⋆	Exponential	Power
√	Square Root	Root
⌊	Floor	Minimum
⌈	Ceiling	Maximum
∧	Sort Up	And
∨	Sort Down	Or
¬	Not	Span
|	Absolute Value	Modulus
≤		Less Than or Equal to
<	Enclose	Less Than
>	Merge	Greater Than
≥		Greater Than or Equal to
=	Rank	Equals
≠	Length	Not Equals
≡	Depth	Match
≢	Shape	Not Match
⊣	Identity	Left
⊢	Identity	Right
⥊	Deshape	Reshape
∾	Join	Join to
≍	Solo	Couple
↑	Prefixes	Take
↓	Suffixes	Drop
↕	Range	Windows
»	Nudge	Shift Before
«	Nudge Back	Shift After
⌽	Reverse	Rotate
⍉	Transpose	Reorder axes
/	Indices	Replicate
⍋	Grade Up	Bins Up
⍒	Grade Down	Bins Down
⊏	First Cell	Select
⊑	First	Pick
⊐	Classify	Index of
⊒	Occurrence Count	Progressive Index of
∊	Unique Mask	Member of
⍷	Deduplicate	Find
⊔	Group Indices	Group

Modifiers

1-modifiers in BQN use superscript symbols, while 2-modifiers use symbols with a circle, but not one with a line through it like ⌽ and ⍉.

Glyph Name(s) ˙ Constant ˜ Self/Swap ˘ Cells ¨ Each ⌜ Table ⁼ Undo ´ Fold ˝ Insert ` Scan

Glyph Name(s) ∘ Atop ○ Over ⊸ Before/Bind ⟜ After/Bind ⌾ Under ⊘ Valences ◶ Choose ⎉ Rank ⚇ Depth ⍟ Repeat

Some modifiers are closely related, and some of their glyphs are intended to allude to this:

• The three 1-modifers Cells (𝔽˘), Each (𝔽¨), and Undo (𝔽⁼) are equivalent to using a right-operand of ¯1 with the 2-modifiers Rank (𝔽⎉¯1), Depth (𝔽⚇¯1), and Repeat (𝔽⍟¯1). Therefore the 2-modifiers are circled versions of the 1-modifiers (except in the case of Undo/Repeat).
• Under (𝔽⌾𝔾) is in principle equivalent to 𝔾⁼∘𝔽○𝔾. Therefore, ⌾ is a combination of the glyphs ∘ and ○.