link references
---------------
Ի                                  last link as a nilad
Ը                                  last link as a monad
Թ                                  last link as a dyad
ի                                  next link as a nilad
ը                                  next link as a monad
թ                                  next link as a dyad
ɨ                                  this link as a nilad
ɫ                                  this link as a monad
ɬ                                  this link as a dyad

hypers
------
Ξ              <link>Ξ             filter; keep
υ              <link>υ             deep recurse, apply to strings as objects not lists
φ              <link>φ             Nth link as a nilad
χ              <link>χ             Nth link as a monad
ψ              <link>ψ             Nth link as a dyad
@              <link>@             swap arguments
                                   for monads, convert to a dyad and use the right argument
                                   for nilads, convert to a dyad and ignore the arguments
/              <link>/             reduce
               <link><nilad>/      n-wise reduce
\              <link>\             cumulative reduce
               <link><nilad>\      n-wise overlapping reduce
`              <link>`             selfie; repeat argument
                                   for dyads, convert to a monad and use the argument on both sides
                                   for monads, convert to a dyad and use the left argument
                                   for nilads, convert to a monad and ignore the argument
‖              <link>‖             filter; discard
ᴀS             <link>ᴀS            custom recursively defined sequence (seq[1] is left argument, seq[x] = f(seq[x - 1]))
ᴀF             <link>ᴀF            fibonacci-like sequence; seq[1], seq[2] is left argument, seq[x] = f(seq[x - 2], seq[x - 1]) (implicit duplicate)
Ͼ              <link>Ͼ             map over the left argument; nilads become monads
Ͽ              <link>Ͽ             map over the right argument; monads become dyads and use the right argument only (equivalent to <link>Ͼ@)

combinators
-----------
?              <f><g><h>?          if statement; if h, f, otherwise, g (defaults to <f> identity <h> ?) (defaults to 1 0 <h> ?) (defaults to 1 0 identity ?)
ᴀs             <f><g>ᴀs            custom two-way recursively defined sequence (seq[1] is left argument, seq[x] = f(seq[x + 1])), seq[x] = g(seq[x - 1])
ᴀf             <f><g>ᴀf            bidirectional fibonacci-like sequence; seq[1], seq[2] is left argument,
                                           seq[x] = f(seq[x + 2], seq[x + 1]), seq[x] = g(seq[x - 2], seq[x - 1]) (implicit duplicate)
¿              <f><g>¿             while loop
ʔ              <f><g>ʔ             while loop; collects all truthy results (including the initial value)