[a-]                            pop
[ab-ba]                         swap
[a-aa]                          dup

[[[[a A]]a A])]                 uncons
[[[a b][a]b,](]                 cons

"operators"

[[]!]                           id
[uncons pop]                    first
[uncons 'pop`]                  rest
[|first]                        last
[''`]                           unit
[unit cons]                     pair
[uncons first]                  unpair
[swapd swap]                    bot             "rot"
[swap swapd]                    top             "-rot"
['pop`]                         popd
['dup`]                         dupd
['cons`]                        consd
['swap`]                        swapd
['`cons`]                       dipd
[swap cons]                     swons
[1+]                            succ
[-1+]                           pred
[-1*]                           neg
[0 swap/first]                  proto
[unit pair.]                    of              "x y"

"continuations"

[[[pop[]]`]$]                           clearstack
[[pop[]]$]                              clearqueue
[[][]]                                  clear

[[[|uncons|swap]`swapunit,]$]           queue
[[|uncons|[unit,]`]$]                   unqueue

[[[dup unit,]`]$]                       stack
[['last`]$]                             unstack

"predicates"

[#ints~]                                atom            "@x"
[atom not]                              list            "~@x"
[count 0=]                              empty           "~#x"
[0~]                                    false           "0~x"
[false~]                                true            "~false x"

"monads"

[0=]                                    not             "~x"
[#first]                                count           "#x"
[1 swap%]                               recip           "%x"
[<|]                                    down            ">x"

"dyads"

[swap>]                                 less            "x<y"
[not'not`&not]                          or              "x|y"
[neg'neg`&neg]                          max             "x|y"

"dict"

[[@unpair swap]`'?right unit[null,]`of]                 aget            "d s aget!"

"controls"

[pair'dupd`'!`swap false pair .!]                       cond            "[c][t][f]cond!"
[[]cond]                                                if              "[c][t]if!"
[unit cons dup[uncons uncons pop ]`'while,,if]          while           "[c][t]while!"
[unit'pred swap,'`,[]swap while pop]                    do              "n[f]do!"

"adverbs"

[['`cons]'swap`do!]                                     I               "n[f]I!"
['!,`]                                                  D               "[f]D!"

[pair[dup unit swap]`unpair
 '@`[dup count]`swap
 ['uncons`'consd`dup swapd
 [[,!dup'swons`]`]`]
 do pop pop pop|]                                       Over            "s[..][f]Over!"

[Over last]                                             over            "s[..][f]over!"

['unit`over]                                            fold            "s[..][f2]fold!"

[swap dup proto swap unit bot over]                     reduce          "[..][f2]reduce!"
[swap dup proto swap unit bot Over 1 swap\]             scan            "[..][f2]scan!"

['+reduce]                                              sum             "[..]sum!"
['+scan]                                                cum             "[..]cum!"

[pair 1 swap unpair'& fold]                             all             "[..][b]all!"
[pair 0 swap unpair'or fold]                            some            "[..][b]some!"

[[dup count[]top]`swap
 ['uncons`dup top[cons unit . first swons]dipd]
 do pop pop|]                                           map             "[..][f]map!"

['@`'!swap,map]                                         each            "map of flip of"
[bot'swap bot,cons map]                                 right           "x[..][f]right!"
[cons map]                                              left            "[..]x[f]left!"
[[pair@]`'!swap,map]                                    both            "[..][..][f]both!"

['!swap,dupd[[1\]`pair]`each -1 swap\]                  prior           "[..][f2]prior!"
['-prior]                                               delta           "[..]delta!"

['dup`swap'map`swap@of]                                 filter          "[..][f]filter!"

[stack'filter`
 |uncons['not,]`cons|'filter,unit . last swap]          split           "[..][f]split!"

['stack dipd
 ['unit map',right]`
 ',left[unit . last]map]                                Map             "..[..][f]Map!"

['@`'!swap,Map]                                         Each            "Map of flip of"
[bot'swap bot,cons Map]                                 Right           "..x[..][f]Right!"
[cons Map]                                              Left            "..[..]x[f]Left!"
[[pair@]`'!swap,Map]                                    Both            "[..][..][f]Both!"

['!swap,dupd[[1\]`pair]`Each -1 swap\]                  Prior           "[..][f2]Prior!"
['-Prior]                                               Delta           "[..]Delta!"

['dup`swap!'Map`swap@of]                                Filter          "[..][f]Filter!"

[stack'Filter`
 |uncons['not,]`cons|'Filter,unit . last swap]          Split           "[..][f]Split!"

[[dupd dupd'pair`swapd]!
 [[bot'!`swap dup]`pair[pair dup unpair swap in]`swap]
 [pop first - 1 swap\]
 [[|unpair cons]`unpair 2[Converge []].\!]
 cond]                                                  Converge        "x[f]Converge!"

[Converge last]                                         converge        "x[f]Converge!"

[['unit`pair|]cons'.,Converge]                          Vector          "i iv Vector!"
[Vector last]                                           vector          "i iv vector!"

[]                                                      matrix          "i j im matrix!"
[]                                                      Matrix          "i j im Matrix!"