Operator Table

	Description
↑	Float power
	Remove item
↓	Rational power
	Insert item
←	Logical NOT N_0 AND N_1
	Prepend
→	Logical N_0 AND NOT N_1
	Append
⟨	Min
⟩	Max
⌈	Ceiling
	Final item
⌉	Round
	All items before final
⌊	Floor
	First item
⌋	Truncate (to integer)
	All items after first
∞	Infinity
↕	Group digits
	Group items
↔	Integer part
	Is safe number
	Flat
⌐	Reciprocal
	Reverse
¬	Logical NOT
¦	Code point
∂	Fractional part
	Sort (min -> max)
∫	Is alphanumerical
	Cumulative sum
Δ	Distance
∂	To alpha
	Is alpha
	Array delta
≡	Conditional (0n or 1n)
≠	Not identical
≤	Less than or equal
≥	Greater than or equal
÷	Integer division
±	Compare
	No-op (0n)
!	Factorial
	Prefixes
%	Modulo
&	Logical AND
(	Range [N_0, N_1)
	Read dictionary
)	Overwrite
	Write dictionary
*	Multiply
+	Add
,	Pair
-	Subtract
.	Wrap
/	Float divide
0	0
1	1
2	2
3	3
4	4
5	5
6	6
7	7
8	8
9	9
:	String concat
;	Array concat
<	Less than
=	Identical
>	Greater than
A	All factors
	Permutations
B	Base convert
C	Bitwise OR
	Combinations of N items
D	Base convert to numbers
E	Hexadecimal convert
F	N_0 * 10 ** N_1
	Slice from
G	Fractional part as string
	Group into pairs
H	Bitwise AND
	Permutations of N items
I	Is prime
	All items are identical
J	To fixed point
	Index of item
K	N_0 / 10 ** N_1
	Slice to
L	N_0 * 2 ** N_1
	Rotate left
M	Multiply by 10
	Array minimum
N	Binary convert
O	Prime factors
	Orderings
P	Nth prime
	All slices
Q	Root
	Repeat items in place
R	N_0 / 2 ** N_1
	Rotate right
S	Is between
	Slice between
T	Ternary convert
U	Bitwise XOR
	Shift alpha
	Fill
V	Includes
W	Logarithm
	Interleave
X	Multiply by 16
	Array max
Y	Range [1, N_0]
	Overlapping pairs
Z	Range (0, N_0]
	Count all items
[	Nth digit
	Nth item
]	Write digit
	Write item
^	Integer power
	Repeat all items
_	Opposite
	Invert case
	All items to same number type and vectorize
a	To array
b	Binary weight
	Duplicate items
c	Factors
	Combinations
d	Double
f	To float
g	Negative
	To lower case
	Sort (min -> max)
h	Half
i	To integer
j	Log 2
	Mirror horizontally
	Average
k	Take sign
	Take case
	Determine order
l	Length
m	Decrement
	Remove first and final
n	To number
o	Increment
	Duplicate first item
p	Positive (absolute value)
	To upper case
	Sort (max -> min)
q	Square root
	Trim
	Product
r	Round to N_0 places
	Float from significant figures
s	To string
t	Triple
u	Square
	Sum code points
	Sum
v	Unsigned addition
	Partition
w	Determine sign
	Determine case
	Determine if sorted
x	Log 10
	Modes
y	Modulo 2
	Unique
z	[I_Part, F_Part]
	Split
	Join
|	Logical OR
~	Bitwise NOT
	Rotate clockwise
·	Range [0, N_0]
	Array range
Ȧ	Count all digits
	Is number
	Neighbors
Ḃ	Divisible by 2
	Length divisible by 2
Ċ	Divisible by 3
	Length is 1
Ḋ	Divisible by 10
	Length divisible by 10
Ė	Insert (merge)
Ḟ	Nth fibonacci
	Sentence case
	Append sum of previous two items
Ġ	GCD
	Intersection
Ḣ	To 2D array
	Transpose
İ	Significant figures
	Integer from significant figures
Ŀ	LCD
	Union
Ṁ	Nth fibonacci with initial
	Replace all items in N_0 with those in N_1
Ṅ	Is negative
	Is lower case
	Is sorted (min -> max)
Ȯ	Divisible by 8
	Length divisible by 8
Ṗ	Is positive
	Is upper case
	Is sorted (max -> min)
Ṙ	Divisible by 5
	Length is 2
Ṡ	Pad
Ṫ	Range [N_0, N_1]
	Take length
Ẇ	Divmod
	Array difference
Ẋ	Logical NOR
	Shift top N_0 items
Ẏ	Logical NAND
Ż	base 256
	Zip to pairs
ȧ	Is array
ḟ	Is float
ġ	10 ** N_0
	Split with newline
	Join with newline
ḣ	Random float to N_0
	Random integer to N_0
	Random item
ṅ	Is number
ȯ	2 * N_0 - 1
	Is whitespace
	Default filter
ṙ	Random float [0, 1)
ṡ	Is string
ṫ	Type check
ẇ	2 ** N_0
	Split with space
	Join with space
ż	Is integer
Ạ	All (dynamic)
	If
Ḅ	Partition (dynamic)
	Run if random() < N_0
Ḍ	Dictionary map (dynamic)
	For [0, n) (return from final iteration)
Ḥ	Find (dynamic)
	For [1, n]
Ị	Find index (dynamic)
	For [0, n)
Ḳ	Map (dynamic)
	While (return iteration count)
Ḷ	Filter (dynamic)
	Filter over [0, n)
Ṃ	Multidimensional map (dynamic)
	For [0, n]
Ṇ	None (dynamic)
	If not
Ọ	While
Ṛ	Reduce (dynamic)
	If positive
Ṣ	Some (dynamic)
Ṭ	Sort with comparator (dynamic)
	While not identical
Ụ	Sort (min -> max) (dynamic)
	While (decrement counter)
Ṿ	Sort (max -> min) (dynamic)
	While (increment counter)
Ẉ	Zipwith (dynamic)
	For [n, N]
Ỵ	Apply to one item (dynamic)
	For [n, N)
Ẓ	Zipmap (dynamic)
	Run as monad
↵	Newline
⁽	Nth program input
⁾	Nth argument
₀	First argument
₁	Second argument
₂	Third argument
₃	Fourth argument
₄	First argument to previous function
₅	Second argument to previous function
₆	Third argument to previous function
₇	First input to program
₈	Second argument to program
₉	Third argument to program
₊	Push stack
₋	Pop stack
₍	Nip stack
₎	Depth of stack
Ɓ	10
Ƈ	11
Ɗ	12
Ƒ	13
Ɠ	14
Ƙ	15
Ɲ	16
Ƥ	64
Ƭ	100
Ʋ	256
Ⱳ	1000
Ȥ	1024
⅛	1000000
¼	4294967296
½	-Infinity
¾	-1