BQN–J dictionary

A guide to help users of J get up to speed with BQN quickly. For a higher-level comparison, check Why BQN?.

Terminology

Array model

BQN uses the based array model, which is fundamentally different from J's flat array model. BQN uses non-array values such as characters and numbers, called "atoms", while in J every noun is an array. A BQN array can contain any values in any mixture, while a J array must be uniformly numbers, characters, or boxes (BQN doesn't use boxes).

The J terms "atom" and "element" are used to mean different things by different authors. In BQN, a rank-0 array or atom is called a "unit", and the values contained in an array—which may or may not be arrays—are called "elements". Each element is contained in a 0-cell, or rank-0 subarray. BQN uses the term "major cell" for what J calls an "item" of an array: a cell with rank one less than that array. BQN shares the terms "list" and "table" for rank-1 and rank-2 arrays with J.

BQN uses "depth" rather than "boxing level". BQN gives atoms depth 0, so that the depth of a BQN array is one higher than the boxing level of the corresponding J array.

Roles

In J, the part of speech is an inherent property of a value, while in BQN it's determined by how the value is used in a particular expression, and can be different from the value's type. See context-free grammar.

Syntax

BQN's explicit functions and modifiers are called blocks, and have a more sophisticated syntax than J. BQN uses lexical scope, and has no global variables. BQN also has a list notation using ⟨⟩, and [] for higher-rank arrays.

For reading

J analogues of BQN primitive functions are given below. They are not always the same; usually this is because BQN has extra functionality relative to J, although in some cases it has less or different functionality.

Functions + - | < > are the same in both languages.

Most of BQN's combinators have J equivalents. The J equivalent "_ for ˙ assumes a noun operand, but ˙ makes a constant function for any operand. ◶ has arguments reversed relative to @., and uses an actual array of functions rather than gerunds. Besides these, BQN's ⟜ is like a J hook, that is, F⟜G is (F G), and ⊸ applies in the opposite direction.

For other modifiers the correspondence is looser. Here ⌜ shows the dyadic case and ´ ˝ the monadic case only.

For writing

J's primitive nouns are easily defined in BQN.

Functions + - | < > are the same in both languages.

Some other primitives are essentially the same in J and BQN, but with different spellings (but transpose behaves differently; J's dyadic |: is more like ⍉⁼):

The tables below give approximate implementations of J primitives. J has a whole lot of complicated primitives that no one uses (some of which are officially deprecated), so not everything is translated here. Operations that only apply to complex numbers are omitted because no BQN implementation currently supports them.

Some J modifier expressions are translated below. BQN doesn't keep track of the rank of functions, so the "close" compositions @ & &. have no BQN equivalents: instead, specify a rank after composing.

BQN uses functions, not modifiers, for structural manipulation. The following table gives BQN functions corresponding to J's structural modifiers. The result is an array of arrays; use F¨ to apply a function to each of these, and >F¨ to apply a function and merge the results into a single array.