# Mnemonics

The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.

Mnemonics can assist with learning the meaning of APL glyphs and where on they keyboard they are found for typing them. Both of these skills are essential for an effective APL programmer. This article provides such aide-mémoires.

## Pairing glyphs with their meaning

Many glyphs have meaning identical to their mathematical counterparts.

`⋄` (Diamond) separates statements. That is, no functions or operators can break through `⋄`, just as diamonds are virtually indestructible.

`⌺` looks like a `⋄`-shaped Stencil laid on a piece of paper, `⎕`.

`!` is Binomial in addition to Factorial, as the two are closely related.

I-beam `⌶` does look like an I-beam

`⌶` (I-beam) calls system services. APL was originally developed at IBM, so system services were also IBM services. `⌶` is an I-beam and I-beam is pronounced almost identically to IBM.

`@` applies a function or substitutes elements at specific locations.

The Grade glyphs `⍋` and `⍒` look like supersonic transports.

`⍋` and `⍒` give the indices (grades) needed to sort ascending and descending respectively, and look like an ascending and descending supersonic transport, respectively.

`⌽`, `⊖`, and `⍉` reverse or transpose an array over a given axis. The `○` part of the glyphs symbolise the array, while the line component (`|`, `\`, or `-`) indicates the line across which the reversal/transposal is done.

The Log glyph `⍟` looks like a tree log.

`⍟` looks like the cross-section of a tree log

`⍱` and `⍲` (Nor and Nand) have the Not glyph `~` on top of or overlaid on the Or glyph `∨` and And glyph `∧` respectively.

`×` can be seen as an ${\displaystyle x}$  when monadic, indicating the unknown sign to be determined.

`+` negates the imaginary part (that is, it conjugates) by analogy to monadic `-` which negates both the real and the imaginary parts.

`÷` takes a default left argument of `1` (thus computing the reciprocal), that being the identity element of division.

`⌹` is matrix divide with a `⎕` symbolising a matrix and an inscribed `÷` for "divide".

`?` symbolises the unknown, and thus rolls dice and deals cards randomly.

`⍺` and `⍵` are the leftmost and rightmost letters of the Greek alphabet. They therefore denote the left and right arguments of dfns, respectively.

`∊` is the Greek letter Epsilon which corresponds to the letter E for Enlist and Element of.

`⍴` is the Greek letter Rho which corresponds to the letter R for Reshape.

`~` is Not when monadic, but its dyadic form, Without, can also be remembered as but not.

`⍨` is a monadic operator that looks like a face. When its derived function is applied monadically, it can be called selfie, in that it applies the operand function to the argument with the argument itself as left argument too.

`↑` and `↓` (Mix and Split) increase and decrease rank (if possible) when used monadically.

`↓` drops elements, and so it points down, the direction in which things are dropped. Take uses `↑` by analogy.

`⍳` is the Greek letter Iota which corresponds to the letter I for Index generator and Index of.

`⍸` is also the Greek letter Iota which corresponds to the letter I for Indices and Interval Index.

`○` is a circle for Circular functions and the ratio between the circumference and the diameter of a circle, Pi.

`⍥` and `⍤` (Over and Atop) both apply the left operand after the right operand. However, `⍥` has a larger "circle of influence" in that it applies its right operand twice (once on each argument) while `⍤` only applies it once (between the arguments).

`*` and `⍣` repeatedly apply multiplication and a function, respectively. The star symbolises power (function)/power (operator).

`←` assigns by putting the value on its right into the name on its left.

`→` points at the destination it is branching to.

`⍬` (Zilde) is a combination of `~` for Without and `0` indicating numbers. Indeed, it is the "vector without numbers", equivalent to `0~0`.

`⊣` and `⊢` point a finger towards the left and right, which are exactly the argument they, respectively, return.

The Quad glyph `⎕` looks like a console.

`⎕` is the prefix for all system names, and also also manages input from the console as well as output to the console. For that, it is a stylised console. `⍞` looks like a `⎕` with a quote `'` indicating string input and message output.

`⌈` and `⌊` are pictograms of a wall with a piece of ceiling and floor, respectively.

`⌈` and `⌊` can also be seen as indicators on a vertical number line, pointing at the maximum and minimum, respectively.

`∇` is an upside-down Greek Delta, which corresponds to the letter D for Defined function or (own) definition (for recursion).

`⌸` (Key) applies a function for each collection of all elements that are equal (`⌸`).

`≡` can be see as a stack of layers. When used monadically, it finds the depth of an array.

`≢` looks like a tally mark. It being sideways can be justified by it counting the length of the leading axis; the vertical axis of a matrix.

`⊂` encloses its argument in a layer of nesting, and Disclose uses `⊃` by analogy. `⊆` is exactly like `⊂` except that it only does a conditional enclose, namely only if the argument is simple.

`⊂` and `⊆` enclose at specific locations, per a specification, so their dyadic forms are Partitioned enclose and Partition, respectively.

`∪` is a styled letter U for Unique or Union if used dyadically.

`⊥` looks like the base of a pillar. Antibase uses `⊤` by analogy.

The Lamp glyph `⍝` looks like a a lamp bulb filament.

`⍝` looks like a filament lamp and provides enlightenment by indicating comments.

`,` concatenates arrays, much like the common punctuation symbol concatenates phrases. `⍪` has an added styled row, indicating that for matrices, it concatenates additional rows.

`.` is just a low dot, but performs the same operation (though generalised) as traditional mathematics' dot product.

`/` and `⌿` are also called "by" which can be remembered as reduce by.

## Pairing glyphs/functionality with their keyboard locations

This list is incomplete; you can help by expanding it.

Below is a US English APL keyboard layout (from Dyalog APL), annotated with short mnemonics. Some of the mnemonics are then fully explained.

`⋄` begins new APL expressions just like ` button begins the main section of the keyboard.
`⌺` is a modified version of `⌺`, so it is Shift+`⋄`.

`¨` applies a function to each 1 of the argument elements, so it is on APL+1.
`⌶` looks like a Roman numeral 1, so it also lives on the 1.

`¯`, `<`, `≤`, `=`, `≥`, `>`, and `≠` form a block. The number line 1–9 (because 0 on the far right) is split into two equal halves by 5 so that gives `=`. 4 and 6 are slightly less and more, respectively, so they give `≤` and `≥`. 3 and 7 are much less and more, respectively, so they give `<` and `>`. Finally, 2 is so much less that it is negative, giving the negative sign `¯`, and 8 is so much greater that it is completely unequal, `≠`.

APL development 
Interface SessionTyping glyphs (on Linux) ∙ FontsText editors
Publications IntroductionsLearning resourcesSimple examplesAdvanced examplesMnemonicsStandardsA Dictionary of APLCase studiesDocumentation suitesBooksPapersVideosPeriodicalsTerminology (Chinese, German) ∙ Neural networksError trapping with Dyalog APL (in forms)
Sharing code Backwards compatibilityAPLcartAPLTreeAPL-CationDfns workspaceTatinCider
Implementation Developers (APL2000, Dyalog, GNU APL community, IBM, IPSA, STSC) ∙ ResourcesOpen-sourceMagic functionPerformanceAPL hardware
APL glyphs 
Information GlyphTyping glyphs (on Linux) ∙ UnicodeFontsMnemonicsOverstrikesMigration level
Individual glyphs Jot (`∘`) ∙ Right Shoe (`⊃`) ∙ Up Arrow (`↑`) ∙ Zilde (`⍬`) ∙ High minus (`¯`) ∙ Dot (`.`) ∙ Del (`∇`)