"operators"

[[]!]                           id
[:/]                            first
[:'/`]                          rest
[(first]                        last
[''`]                           unit
[unit;]                         pair
[:first]                        unpair
[swapd\]                        bot             "rot"
[\swapd]                        top             "-rot"
['/`]                           popd
['|`]                           dupd
[';`]                           consd
['\`]                           swapd
['`;`]                          dipd
[\;]                            swons
[1+]                            succ
[1 -]                           pred
[1-*]                           neg
[0\{first]                      proto
[unit pair .]                   of              "x y"

"continuations"

[[[/[]]`]$]]                    clearstack
[[/[]]$]                        clearqueue
[[][]]                          clear

[[[(:(\]`\unit,]$]              queue
[[(:([unit,]`]$]                unqueue

[[[|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\%]                           rec             "/x"
[<(]                            down            ">x"
[not![not!]`&not!]              or              "x|y"
[neg![neg!]`&neg!]              max             "x|y"
[@/]                            unique          "?x"
[@\/]                           group           "=x"

"dyads"

[\>]                            less            "x<y"

"dict"

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

"controls"

[pair'dupd`'!`\false pair .!]                   cond            "[c][t][f]cond"
[[]cond]                                        if              "[c][t]if"
[unit;|[::/]`'while,,if]                        while           "[c][t]while"
[unit'pred\,'`,[]\while/]                       do              "n[f]do"

"adverbs"

[['`;]'\`do!]                                   I               "n[f]I"
['!,`]                                          D               "[f]D"

[pair[|unit\]`unpair
 ')`[|count]`\
 [':`'consd`|swapd
 [[,!|'swons`]`]`]
 do///(]                                        Over            "s[..][f]Over"

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

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

[\|proto\unit bot over]                         reduce          "[..][f2]reduce"
[\|proto\unit bot Over 1\}]                     scan            "[..][f2]scan"

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

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

[[|count[]top]`\
 [':`|top[;unit . first swons]dipd]
 do//(]                                         map             "[..][f]map"

[')`'!\,map]                                    each            "map of flip of"
[bot'\bot,;map]                                 right           "x[..][f]right"
[;map]                                          left            "[..]x[f]left"
[[pair)]`'!\,map]                               both            "[..][..][f]both"

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

['|`\'map`\)of]                                 filter          "[..][f]filter"

[stack'filter`
 (:['not,]`;('filter,unit . last\]              split           "[..][f]split"

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

[')`'!\,Map]                                    Each            "Map of flip of"
[bot'\bot,;Map]                                 Right           "..x[..][f]Right"
[;Map]                                          Left            "..[..]x[f]Left"
[[pair)]`'!\,Map]                               Both            "[..][..][f]Both"

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

['|`\'Map`\)of]                                 Filter          "[..][f]Filter"

[stack'Filter`
 (:['not,]`;('Filter,unit . last\]              Split           "[..][f]Split"

[[dupd dupd'pair`swapd]!
 [[bot'!`\|]`pair[pair|unpair\in]`\]
 [/first(1\}]
 [[(unpair;]`unpair 2[Converge []].}!]
 cond]                                          Converge        "x[f]Converge"

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

[['unit`pair(];'.,Converge]                     Vector          "i iv Vector"
[Vector last]                                   vector          "i iv vector"

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