A few tables to help users of Dyalog APL (or similar) get started quickly on BQN. Here we assume `⎕ML`

is 1 for Dyalog.

BQN uses the based array model, so that a Dyalog simple scalar corresponds to many BQN values: an atom, its enclose, and so on.

Dyalog | BQN |
---|---|

Simple scalar | Atom |

Scalar | Unit |

Vector | List |

Matrix | Table |

BQN shares the terms "cell" and "major cell" with Dyalog, and uses
"element" (which may mean different things to different Dyalog users) *not* for a 0-cell but for the value it contains.

Dyalog uses value types (array, function, and so on) to determine syntax while BQN uses a separate concept called syntactic roles. See context-free grammar.

Dyalog type | BQN role |
---|---|

Array | Subject |

Function | Function |

Monadic operator | 1-modifier |

Dyadic operator | 2-modifier |

Niladic function | go away |

BQN comments are written with `#`

, not `⍝`

. BQN strings use double quotes `""`

while single quotes `''`

enclose a character.

BQN's functions use `{}`

, like Dyalog's dfns. The names for inputs and self-reference are different:

Dyalog | BQN |
---|---|

`⍺` |
`𝕨` |

`⍵` |
`𝕩` |

`∇` |
`𝕊` |

`⍺⍺` |
`𝔽` |

`⍵⍵` |
`𝔾` |

`∇∇` |
`𝕣` |

BQN doesn't have guards: it uses modifiers or control structures instead. However, BQN function and modifier blocks have headers that allow pattern matching. See the block documentation.

The assignment arrow `←`

defines a new variable in a block, while `↩`

modifies an existing one.

BQN uses the ligature character `‿`

for stranding, instead of plain juxtaposition. It also has a list notation using `⟨⟩`

.

Here are some closest equivalents in Dyalog APL for the BQN functions that don't use the same glyphs as APL. Correspondence can be approximate, and `⌽`

is just used as a decorator to mean "reverse some things".

BQN | `⋆` |
`√` |
`∧` |
`∨` |
`¬` |
`=` |
`≠` |
`<` |
`>` |
`≢` |
`⥊` |
---|---|---|---|---|---|---|---|---|---|---|---|

Monad | `*` |
`*∘(÷2)` |
`[⍋]` |
`[⍒]` |
`~` |
`≢⍤⍴` |
`≢` |
`⊂` |
`↑` |
`⍴` |
`,` |

Dyad | `*` |
`*∘÷⍨` |
`∧` |
`∨` |
`1+-` |
`=` |
`≠` |
`<` |
`>` |
`≢` |
`⍴` |

BQN | `∾` |
`≍` |
`↑` |
`↓` |
`↕` |
`»` |
`«` |
---|---|---|---|---|---|---|---|

Monad | `⊃,⌿` |
`↑,⍥⊂` |
`,⍀` |
`⌽,⌽⍀⌽` |
`⍳` |
`≢↑(¯1-≢)↑⊢` |
`-⍤≢↑(1+≢)↑⊢` |

Dyad | `⍪` |
`↑,⍥⊂` |
`↑` |
`↓` |
`,⌿` |
`≢⍤⊢↑⍪` |
`-⍤≢⍤⊢↑⍪⍨` |

BQN | `/` |
`⍋` |
`⍒` |
`⊏` |
`⊑` |
`⊐` |
`⊒` |
`∊` |
`⍷` |
`⊔` |
---|---|---|---|---|---|---|---|---|---|---|

Monad | `⍸` |
`⍋` |
`⍒` |
`⊣⌿` |
`⊃` |
`∪⍳⊢` |
`…` |
`≠` |
`∪` |
`⌸` |

Dyad | `⌿` |
`⍸` |
`⌽⍸⌽` |
`⌷` |
`⊃` |
`⍳` |
`…` |
`∊` |
`⍷` |
`⌸` or `⊆` |

Modifiers are a little harder. Many have equivalents in some cases, but Dyalog sometimes chooses different functionality based on whether the operand is an array. In BQN an array is always treated as a constant function.

BQN | `¨` |
`⌜` |
`˝` |
`⎉` |
`⍟` |
`˜` |
`∘` |
`○` |
`⟜` |
---|---|---|---|---|---|---|---|---|---|

Dyalog | `¨` |
`∘.` |
`⌿` |
`⍤` |
`⍣` |
`⍨` |
`⍤` |
`⍥` |
`∘` |

In BQN `⎉`

is Rank and `∘`

is Atop. Dyalog's Atop (`⍤`

) and Over (`⍥`

) were added in version 18.0.

The tables below give approximate implementations of Dyalog primitives for the ones that aren't the same. First- and last-axis pairs are also mostly omitted. BQN just has the first-axis form, and you can get the last-axis form with `⎉1`

.

The form `F⍣G`

(Power with a function right operand; Power limit) must be implemented with recursion instead of primitives because it performs unbounded iteration. The modifier `_while_ ← {𝔽⍟𝔾∘𝔽_𝕣_𝔾∘𝔽⍟𝔾𝕩}`

provides similar functionality without risk of stack overflow. It's discussed here and called as `Fn _while_ Cond arg`

.

Functions | ||
---|---|---|

Glyph | Monadic | Dyadic |

`*` | `⋆` | |

`⍟` | `⋆⁼` | |

`!` | `×´1+↕` | `-˜(+÷○(×´)⊢)1+↕∘⊣` |

`○` | `π⊸×` | `•math` |

`~` | `¬` | `¬∘∊/⊣` |

`?` | `•rand.Range⚇0` | `•rand.Deal` |

`⍲` | `¬∘∧` | |

`⍱` | `¬∘∨` | |

`⍴` | `≢` | `⥊` |

`,` | `⥊` | `∾⎉1` |

`⍪` | `⥊˘` | `∾` |

`⌽` | `⌽⎉0‿1` | |

`↑` | `>` | `↑` |

`↓` | `<˘` | `↑` |

`⊂` | `<` | `+`⊸⊔` |

`⊆` | `<⍟(0<≡)` | `⊔` |

`∊` | `{(∾𝕊¨)⍟(0<≡𝕩)⥊𝕩}` | `∊` |

`⊃` | `⊑` | |

`⍀` | `/⁼` | |

`∩` | `∊/⊣` | |

`∪` | `⍷` | `⊣∾∊˜¬⊸/⊢` |

`⍳` | `↕` | `⊐` |

`⍸` | `/` | `⍋` |

`⍋` | `⍋` | Give up |

`⍒` | `⍒` | Give up |

`≢` | `≠` | `≢` |

`⍎` | `•Eval` | |

`⍕` | `•Fmt` | |

`⊥` | `{+⟜(𝕨⊸×)´⌽𝕩}` | |

`⊤` | `{>𝕨|⌊∘÷`⌾⌽𝕨«˜<𝕩}` | |

`⌹` | `+˝∘×⎉1‿∞⁼` I guess | |

`⌷` | N/A | `⊏` |

Operators | ||
---|---|---|

Syntax | Monadic | Dyadic |

`⌿` | `¨˝` | `↕` |

`⍀` | `↑` , or ``` if associative | |

`¨` | `¨` | |

`⍨` | `˜` | |

`⍣` | `⍟` | |

`f.g` | `f˝∘g⎉1‿∞` | |

`∘.f` | `f⌜` | |

`A∘g` | `A⊸g` | |

`f∘B` | `f⟜B` | |

`f∘g` | `f⟜g` | |

`f⍤B` | `f⎉B` | |

`f⍤g` | `f∘g` | |

`f⍥g` | `f○g` | |

`f@v` | `f⌾(v⊸⊏)` | |

`f⍠B` | Uh | |

`f⌸` | `⊐⊔↕∘≠` | `⊐⊸⊔` |

`f⌺B` | `↕` | |

`A⌶` | `•Something` | |

`f&` | Nothing yet |