(note: if a specified type combination isn't listed, it probably vectorizes)

nilads
------
α                                  left argument, or 'yuno'
ι                                  [1, 2, 3, ...]
ω                                  right argument, or []
³                                  1st argument, or '\n'
⁴                                  2nd argument, or ' '
⁵                                  3rd argument, or 64
⁶                                  4th argument, or 32
⁷                                  5th argument, or 100
⁸                                  6th argument, or 256
⁹                                  7th argument, or 10

math/misc nilads
----------------
ᴍI                                 infinity
ᴍX                                 Math.random()

I/O nilads
----------
ɵE                                 read and evaluate a line of yuno code (niladically)
ɵI                                 read a line of input as a string

digraph nilads are at /static/various-nilads.txt

monads
------
Σ   (z: any)                       Sum (implicit range)
!   (z: num)                       Factorial / (+1) . Gamma
    (z: str)                       ?
A   (z: num)                       Absolute Value
    (z: chr)                       Uppercase
B   (z: num)                       Integer to Base 2; Binary
    (z: str)                       ?
C   (z: num)                       Complement; 1 - z
    (z: chr)                       Flip case; Swap case
D   (z: num)                       Integer to Base 10; Decimal
    (z: str)                       ?
E   (z: any)                       All Equal? (implicit stringify)
F   (z: any)                       Flatten fully
H   (z: num)                       Halve
    (z: str)                       divide a string into halves, short if of odd length
I   (z: any)                       Increments (vectorizes to depth 1) - characters become their codepoints
J   (z: any)                       Range of length
L   (z: num)                       Stringified length
    (z: any)                       Length
M   (z: )
N   (z: num)                       Negate; -z
    (z: chr)                       ?
O   (z: num)                       chr
    (z: chr)                       ord
P   (z: num)                       Primality check; Is prime
    (z: chr)                       ?
Q   (z: any)                       Uniquify; unique elements ordered by first appearance
R   (z: re )                       Upper range; [1, 2, ..., z] or [0, -1, ..., z + 1]
    (z: im )                       Upper range; [i, 2i, ..., z] or [0, -i, ..., z + i]
    (z: cmp)                       Cartesian product over sum of the above
    (z: chr)                       Character range from "A"
T   (z: any)                       Indices of truthy elements (implicit lowered range, implicit codepoint)
U   (z: any)                       Upend; reverse (vectorize to depth 1) (implicit range)
ᴅ   (z: any)                       Depth
ᴘ   (z: any)                       Product (implicit range)
ʀ   (z: re )                       Lower range; [0, 1, ..., z - 1] or [-1, -2, ..., z]
    (z: im )                       Lower range; [0, i, ..., z - i] or [-i, -2i, ..., z]
    (z: cmp)                       Cartesian product over sum of the above
    (z: chr)                       Character range from "a"
ɾ   (z: re )                       Outer range; [0, 1, ..., z] or [0, -1, ..., z]
    (z: im )                       Outer range; [0, i, ..., z] or [0, -i, ..., z]
    (z: cmp)                       Cartesian product over sum of the above
    (z: chr)                       Character range from "Γ"
ʁ   (z: re )                       Inner range; [1, 2, ..., z - 1] or [-1, -2, ..., z + 1]
    (z: im )                       Inner range; [i, 2i, ..., z - i] or [-i, -2i, ..., z + i]
    (z: cmp)                       Cartesian product over sum of the above
    (z: chr)                       Character range from "!"
¹   (z: any)                       z; identity; z => z
²   (z: num)                       z * z; square; squared
    (z: str)                       format z as square
¬   (z: any)                       logical NOT (vectorizing)
Ϩ   (z: num)                       square root
    (z: str)                       divide a string into halves, overlapping if of odd length
‘   (z: num)                       z - 1; decrement
    (z: str)                       string decrement
’   (z: num)                       z + 1; increment
    (z: str)                       string increment

array/seq monads
----------------
ᴀM  (z: any)                       Indices of maximal elements (implicit range)
ᴀR  (z: num)                       Mirrored Range; equivalent to (Nr)
    (z: chr)                       ?
ᴀᴍ  (z: any)                       Indices of minimal elements (implicit range)

math/misc monads
----------------
ᴍC  (z: any)                       chr
ᴍO  (z: any)                       ord

I/O monads
----------
ɵA  (z: any)                       alert a stringified form and return z
ɵG  (z: any)                       format into a grid (string)
ɵH  (z: any)                       format into a grid, left-aligned (string)
ɵK  (z: any)                       join on spaces, stringifying all values
ɵN  (z: any)                       output z with a trailing newline
ɵ_  (z: any)                       output z
ɵʛ  (z: any)                       format into a grid (list of lines)
ɵɢ  (z: any)                       format into a grid (matrix of strings)
ɵʜ  (z: any)                       format into a grid, left-aligned (matrix of strings)
ɵի  (z: any)                       format into a grid, left-aligned (list of lines)

dyads
-----
β   (x: [n], y: num)               convert x from base y (x => [x] if necessary)
    (x: str, y: num)               convert x from base y up to 36
    (x: num, y: str)               convert y from base x up to 36
    (x: str, y: str)               ?
%   (x: num, y: num)               modulo (python-style) (removes complex component)
    (x: str, y: num)               ?
    (x: num, y: str)               ?
    (x: str, y: str)               ?
*   (x: num, y: num)               x ** y; exponentiation; power
    (x: str, y: num)               ?
    (x: num, y: str)               ?
    (x: str, y: str)               ?
+   (x: num, y: num)               x + y; addition; plus; add
    (x: str, y: num)               x + y.toString(); concatenation
    (x: num, y: str)               x.toString() + y; concatenation
    (x: str, y: str)               x + y; concatenation
,   (x: any, y: any)               [x, y]; pair; append false-false tightening
:   (x: num, y: num)               x // y; floor division; floor divide
    (x: str, y: num)               ?
    (x: num, y: str)               ?
    (x: str, y: str)               ?
;   (x: any, y: any)               [...x, ...y]; append; append true-true tightening
<   (x: any, y: any)               x < y; less than (vectorized)
=   (x: any, y: any)               x = y; equal to (vectorized)
>   (x: any, y: any)               x > y; greater than (vectorized)
_   (x: num, y: num)               x - y; subtraction; minus
    (x: chr, y: num)               chr(ord(x) - y); caesar cipher (ignores complex component)
    (x: num, y: chr)               chr(ord(y) + x); caesar cipher (ignores complex component)
    (x: chr, y: chr)               ?
b   (x: num, y: num)               convert x to base y (removes the imaginary component of y)
    (x: str, y: num)               convert y into arbitrary custom base x
    (x: num, y: str)               convert x into arbitrary custom base y
    (x: chr, y: chr)               ?
i   (x: [ ], y: any)               find the first index of y in x (0 if not found; freezes on infinite lists; will not scan backwards)
r   (x: num, y: num)               Inclusive Range (re, re => [re]; im, im => [im]; otherwise => cartesian product over +)
    (x: chr, y: num)               ?
    (x: num, y: chr)               ?
    (x: chr, y: chr)               Character Range
ɐ   (x: [ ], y: [ ])               sublist index; find the position of sublist x in y (implicit digits)
ɨ   (x: num, y: [ ])               find the element at index x of y; if x is complex, at real(x) and imag(x); if x is a decimal, at floor(x) and ceil(x)
    (x: chr, y: [ ])               ?
ɲ   (x: any, y: any)               x; left argument
ɳ   (x: any, y: any)               y; right argument
ɹ   (x: num, y: num)               Exclusive Range (re, re => [re]; im, im => [im]; otherwise => cartesian product over +)
    (x: chr, y: num)               ?
    (x: num, y: chr)               ?
    (x: chr, y: chr)               Inverted (Wrapping) Character Range
ɻ   (x: num, y: num)               Exclusive, Inclusive Range (re, re => [re]; im, im => [im]; otherwise => cartesian product over +)
    (x: chr, y: num)               ?
    (x: num, y: chr)               ?
    (x: chr, y: chr)               Backward (Wrapping) Character Range
ɽ   (x: num. y: num)               Inclusive, Exclusive Range (re, re => [re]; im, im => [im]; otherwise => cartesian product over +)
    (x: chr, y: num)               ?
    (x: num, y: chr)               ?
    (x: chr, y: chr)               Forward (Wrapping) Character Range
×   (x: num, y: num)               x * y; multiplication; times
    (x: str, y: num)               pad right to up to y with spaces
    (x: num, y: str)               pad left to up to y with spaces
    (x: str, y: str)               [c + y for c in x]; vectorized concatenation
÷   (x: num, y: num)               x / y; division; divide
    (x: str, y: num)               split each line into segments of at most length y, then join all on newlines; if y == 0, no-op
    (x: num, y: str)               y / x
    (x: str, y: str)               x.match(y); regex match; regex find

array/seq dyads
---------------
ᴀ<  (x: any, y: any)               x < y; less than (non-vectorizing)
ᴀ>  (x: any, y: any)               x > y; greater than (non-vectorizing)
ᴀa  (x: any, y: any)               Arithmetic Sequence; infinite sequence a => x + y * (a - 1)
ᴀg  (x: any, y: any)               Geometric Sequence; infinite sequence a => x * y ** (a - 1)
ᴀ«  (x: any, y: any)               x <= y; less than or equal to (non-vectorizing)
ᴀ»  (x: any, y: any)               x >= y; greater than or equal to (non-vectorizing)

math/misc dyads
---------------
ᴍ<  (x: any, y: any)               x <= y; less than or equal to (vectorized)
ᴍ>  (x: any, y: any)               x >= y; greater than or equal to (vectorized)