chapter 2b, basic containers
============================

Section 2bA, units
------------------

### `++biff`

Unit as argument

    ++  biff                                                ::  apply
      |*  [a=(unit) b=$+(* (unit))]
      ?~  a  ~
      (b u.a)

Applies a gate that produces a unit, `b`, to the value (`u.a`) of a unit
`a`. If `a` is empty, `~` is produced.

`a` is a [unit]().

`b` is a [gate]() that accepts a noun and produces a unit.

    ~zod/try=> (biff (some 5) |=(a=@ (some (add a 2))))
    [~ u=7]
    ~zod/try=> (biff ~ |=(a=@ (some (add a 2))))
    ~

------------------------------------------------------------------------

### `++bind`

Bind

    ++  bind                                                ::  argue
      |*  [a=(unit) b=gate]
      ?~  a  ~
      [~ u=(b u.a)]

Applies a function `b` to the value (`u.a`) of a unit `a`, producing a
unit.

`a` is a [unit]()

`b` is a [gate]().

    ~zod/try=> (bind ((unit ,@) [~ 97]) ,@t)
    [~ `a`]
    ~zod/try=> =a |=(a=@ (add a 1))
    ~zod/try=> (bind ((unit ,@) [~ 2]) a)
    [~ 3]

------------------------------------------------------------------------

### `++bond`

Replace null

    ++  bond                                                ::  replace
      |*  a=trap
      |*  b=(unit)
      ?~  b  $:a
      u.b

Replaces an empty unit `b` with the product of a kicked trap `a`. If the
unit is not empty, then the original unit is produced.

`a` is a [trap]().

`b` is a [unit]().

    ~zod/try=> (bex 10)
    1.024
    ~zod/try=> ((bond |.((bex 10))) ~)
    1.024
    ~zod/try=> ((bond |.((bex 10))) (slaw %ud '123'))
    123

------------------------------------------------------------------------

### `++both`

Group unit values

    ++  both                                                ::  all the above
      |*  [a=(unit) b=(unit)]
      ?~  a  ~
      ?~  b  ~
      [~ u=[u.a u.b]]

Produces a unit whose value is a cell of the values of two input units
`a` and `b`. If either of the two units are empty, `~` is produced.

`a` is a [unit]().

`b` is a [unit]().

    ~zod/try=> (both (some 1) (some %b))
    [~ u=[1 %b]]
    ~zod/try=> (both ~ (some %b))
    ~

------------------------------------------------------------------------

### `++clap`

Apply gate to two units

    ++  clap                                                ::  combine
      |*  [a=(unit) b=(unit) c=_|=(^ +<-)]
      ?~  a  b
      ?~  b  a
      [~ u=(c u.a u.b)]

Applies a binary operation `c` which produces a unit to the values of
two units `a` and `b`.

`a` is a [unit]().

`b` is a [unit]().

`c` is a [gate]() that performs a binary operation.

    ~zod/try=> =u ((unit ,@t) [~ 'a'])
    ~zod/try=> =v ((unit ,@t) [~ 'b'])
    ~zod/try=> (clap u v |=([a=@t b=@t] (welp (trip a) (trip b))))
    [~ u="ab"] 
    ~zod/try=> =a ((unit ,@u) [~ 1])
    ~zod/try=> =b ((unit ,@u) [~ 2])
    ~zod/try=> =c |=([a=@ b=@] (add a b))
    ~zod/try=> (clap a b c)
    [~ 3]
      

------------------------------------------------------------------------

### `++drop`

Unit list

    ++  drop                                                ::  enlist
      |*  a=(unit)
      ?~  a  ~
      [i=u.a t=~]

Produces a [list]() of the value from a unit `a`.

`a` is a [unit]().

    ~zod/try=> =a ((unit ,@) [~ 97])
    ~zod/try=> (drop a)
    [i=97 t=~] 
    ~zod/try=> =a ((unit ,@) [~])
    ~zod/try=> (drop a)
    ~

------------------------------------------------------------------------

### `++fall`

Default unit

    ++  fall                                                ::  default
      |*  [a=(unit) b=*]
      ?~(a b u.a)

Produces a default value `b` for a unit `a` in cases where the unit is
null.

`a` is a [unit]().

`b` is a [noun]() used as the default value.

    ~zod/try=> (fall ~ `a`)
    `a`
    ~zod/try=> (fall [~ u=0] `a`)
    0

------------------------------------------------------------------------

### `++lift`

Fmap

    ++  lift                                                ::  lift gate (fmap)
      |*  a=gate                                            ::  flipped
      |*  b=(unit)                                          ::  curried
      (bind b a)                                            ::  bind

Similar to `fmap` in Haskell: accepts a gate `a` that accepts and
produces an unwrapped value, passes it the value of a unit `b`, and then
produces a unit value.

`a` is a [gate]().

`b` is a [unit]().

    ~zod/try=> ((lift dec) `(unit ,@)`~)
    ~
    ~zod/try=> ((lift dec) `(unit ,@)`[~ 20])
    [~ 19]

------------------------------------------------------------------------

### `++mate`

Choose

    ++  mate                                                ::  choose
      |*  [a=(unit) b=(unit)]
      ?~  b  a
      ?~  a  b
      ?.(=(u.a u.b) ~|('mate' !!) a)

Accepts two units `a` and `b` whose values are expected to be
equivalent. If either is empty, then the value of the other is produced.
If neither are empty, it asserts that both values are the same and
produces that value. If the assertion fails, `++mate` crashes with
`'mate'` in the stack trace.

`a` is a [unit]().

`b` is a [unit]().

    ~zod/try=> =a ((unit ,@) [~ 97])
    ~zod/try=> =b ((unit ,@) [~ 97])
    ~zod/try=> (mate a b)
    [~ 97]
    ~zod/try=> =a ((unit ,@) [~ 97])
    ~zod/try=> =b ((unit ,@) [~])
    ~zod/try=> (mate a b)
    [~ 97]
    ~zod/try=> =a ((unit ,@) [~ 97])
    ~zod/try=> =b ((unit ,@) [~ 98])
    ~zod/try=> (mate a b)
    ! 'mate'
    ! exit

------------------------------------------------------------------------

### `++need`

Unwrap

    ++  need                                                ::  demand
      |*  a=(unit)
      ?~  a  !!
      u.a

Retrieve the value from a unit and crash if the unit is null.

`a` is a [unit]().

    ~zod/try=> =a ((unit ,[@t @t]) [~ ['a' 'b']])
    ~zod/try=> (need a)
    ['a' 'b']
    ~zod/try=> =a ((unit ,@ud) [~ 17])
    ~zod/try=> (need a)
    17
    ~zod/try=> =a ((unit ,@) [~])
    ~zod/try=> (need a)
    ! exit

------------------------------------------------------------------------

### `++some`

Unify

    ++  some                                                ::  lift (pure)
      |*  a=*
      [~ u=a]

Takes any atom `a` and produces a unit with the value set to `a`.

`a` is a [noun]().

    ~zod/try=> (some [`a` `b`])
    [~ u=[`a` `b`]]
    ~zod/try=> (some &)
    [~ u=%.y]

------------------------------------------------------------------------

section 2bB, lists
------------------

Reverse

### `++flop`

    ++  flop                                                ::  reverse
      ~/  %flop
      |*  a=(list)
      =>  .(a (homo a))
      ^+  a
      =+  b=`_a`~
      |-
      ?~  a  b
      $(a t.a, b [i.a b])

Produces the list `a` in reverse order.

`a` is a [list]().

    ~zod/try=> =a (limo [1 2 3 ~])
    ~zod/try=> (flop a)
    ~[3 2 1]

### `++homo`

Homogenize

    ++  homo                                                ::  homogenize
      |*  a=(list)
      ^+  =<  $
        |%  +-  $  ?:(_? ~ [i=(snag 0 a) t=$])
        --
      a

Produces a list whose type is a fork of all the contained types in the
list `a`.

`a` is a [list]().

    ~zod/try=> lyst
    [i=1 t=[i=97 t=[i=2 t=[i=98 t=[i=[~ u=10] t=~]]]]]
    ~zod/try=> (homo lyst)
    ~[1 97 2 98 [~ u=10]]
    ~zod/try=> =a (limo [1 2 3 ~])
    ~zod/try=> a
    [i=1 t=[i=2 t=[i=3 t=~]]]
    ~zod/try=> (homo a)
    ~[1 2 3]

### `++limo`

List Constructor

    ++  limo                                                ::  listify
      |*  a=*
      ^+  =<  $
        |%  +-  $  ?~(a ~ ?:(_? i=-.a t=$ $(a +.a)))
        --
      a

Turns a null-terminated tuple into a list.

`a` is a null-terminated tuple.

    ~zod/try=> (limo [1 2 3 ~])
    [i=1 t=[i=2 t=[i=3 t=~]]]

### `++lent`

List length

    ++  lent                                                ::  length
      ~/  %lent
      |=  a=(list)
      ^-  @
      =+  b=0
      |-
      ?~  a  b 
      $(a t.a, b +(b))

Produces the length of any list `a` as an atom.

`a` is a [list]().

    ~zod/try=> (lent (limo [1 2 3 4 ~]))
    4
    ~zod/try=> (lent (limo [1 'a' 2 'b' (some 10) ~]))
    5

------------------------------------------------------------------------

### `++levy`

"and" to list

    ++  levy
      ~/  %levy                                             ::  all of
      |*  [a=(list) b=_|=(p=* .?(p))]
      |-  ^-  ?
      ?~  a  &
      ?.  (b i.a)  |
      $(a t.a)

Produces the Boolean "and" of the result of every element in list `a`
passed to gate `b`.

`a` is a [list]().

`b` is a [gate]().

    ~zod/try=> =a |=(a=@ (lte a 1))
    ~zod/try=> (levy (limo [0 1 2 1 ~]) a)
    %.n
    ~zod/try=> =a |=(a=@ (lte a 3))
    ~zod/try=> (levy (limo [0 1 2 1 ~]) a)
    %.y

------------------------------------------------------------------------

### `++lien`

"or" to list

    ++  lien                                                ::  some of
      ~/  %lien
      |*  [a=(list) b=$+(* ?)]
      |-  ^-  ?
      ?~  a  |
      ?:  (b i.a)  &
      $(a t.a)

Produces the Boolean "or" of the result of every element in list `a`
passed to gate `b`.

`a` is a [list]().

`b` is a [gate]().

    ~zod/try=> =a |=(a=@ (gte a 1))
    ~zod/try=> (lien (limo [0 1 2 1 ~]) a)
    %.y
    ~zod/try=> =a |=(a=@ (gte a 3))
    ~zod/try=> (lien (limo [0 1 2 1 ~]) a)
    %.n

------------------------------------------------------------------------

### `++murn`

Maybe transform

    ++  murn                                                ::  maybe transform
      |*  [a=(list) b=$+(* (unit))]
      |-
      ?~  a  ~
      =+  c=(b i.a)
      ?~  c
        $(a t.a)
      [i=u.c t=$(a t.a)]

Passes each member of list `a` to gate `b`, which must produce a unit.
Produces a new list with all the results that do not produce `~`.

`a` is a [list]().

`b` is a [gate]() that produces a [unit]().

    ~zod/try=> =a |=(a=@ ?.((gte a 2) ~ (some (add a 10))))
    ~zod/try=> (murn (limo [0 1 2 3 ~]) a)
    [i=12 t=[i=13 t=~]]

### `++reap`

Replicate

    ++  reap                                                ::  replicate
      |*  [a=@ b=*]
      |-  ^-  (list ,_b)
      ?~  a  ~
      [b $(a (dec a))]

Replicate: produces a list containing `a` copies of `b`.

`a` is an [atom]()

`b` is a [noun]()

    ~zod/try=> (reap 20 %a)
    ~[%a %a %a %a %a %a %a %a %a %a %a %a %a %a %a %a %a %a %a %a]
    ~zod/try=> (reap 5 ~s1)
    ~[~s1 ~s1 ~s1 ~s1 ~s1]
    ~zod/try=> `@dr`(roll (reap 5 ~s1) add)
    ~s5

------------------------------------------------------------------------

### `++reel`

Right fold

    ++  reel                                                ::  right fold  
      ~/  %reel
      |*  [a=(list) b=_|=([* *] +<+)]
      |-  ^+  +<+.b
      ?~  a
        +<+.b
      (b i.a $(a t.a))

Right fold: moves right to left across a list `a`, recursively slamming
a binary gate `b` with an element from `a` and an accumulator, producing
the final value of the accumulator.

`a` is a [list]().

`b` is a binary [gate]().

    ~zod/try=> =sum =|([p=@ q=@] |.((add p q)))
    ~zod/try=> (reel (limo [1 2 3 4 5 ~]) sum)
    15
    ~zod/try=> =a =|([p=@ q=@] |.((sub p q)))
    ~zod/try=> (reel (limo [6 3 1 ~]) a)
    4
    ~zod/try=> (reel (limo [3 6 1 ~]) a)
    ! subtract-underflow
    ! exit

------------------------------------------------------------------------

### `++roll`

Left fold

    ++  roll                                                ::  left fold
      ~/  %roll
      |*  [a=(list) b=_|=([* *] +<+)]
      |-  ^+  +<+.b
      ?~  a
        +<+.b
      $(a t.a, b b(+<+ (b i.a +<+.b)))

Left fold: moves left to right across a list `a`, recursively slamming a
binary gate `b` with an element from the list and an accumulator,
producing the final value of the accumulator.

`a` is a [list]().

`b` is a binary [gate]().

    ~zod/try=> =sum =|([p=@ q=@] |.((add p q)))
    ~zod/try=> (roll (limo [1 2 3 4 5 ~]) sum)
    q=15
    ~zod/try=> =a =|([p=@ q=@] |.((sub p q)))
    ~zod/try=> (roll (limo [6 3 1 ~]) a)
    ! subtract-underflow
    ! exit
    ~zod/try=> (roll (limo [1 3 6 ~]) a)
    q=4

------------------------------------------------------------------------

### `++skid`

Separate

    ++  skid                                                ::  separate
      |*  [a=(list) b=$+(* ?)]
      |-  ^+  [p=a q=a]
      ?~  a  [~ ~]
      =+  c=$(a t.a)
      ?:((b i.a) [[i.a p.c] q.c] [p.c [i.a q.c]])

Seperates a list `a` into two lists - Those elements of `a` who produce
true when slammed to gate `b` and those who produce `%.n`.

`a` is a [list]().

`b` is a [gate]() that accepts one argument and produces a loobean.

    ~zod/try=> =a |=(a=@ (gth a 1))
    ~zod/try=> (skid (limo [0 1 2 3 ~]) a)
    [p=[i=2 t=[i=3 t=~]] q=[i=0 t=[i=1 t=~]]]

------------------------------------------------------------------------

### `++skim`

Suffix

    ++  skim                                                ::  only
      ~/  %skim
      |*  [a=(list) b=_|=(p=* .?(p))]
      |-
      ^+  a
      ?~  a  ~
      ?:((b i.a) [i.a $(a t.a)] $(a t.a))

Cycles through the members of a list `a`, passing them to a gate `b` and
producing a list of all of the members that produce `%.y`. Inverse of
`++skip`.

`a` is a [list]().

`b` is a [gate]() that accepts one argument and produces a loobean.

    ~zod/try=> =a |=(a=@ (gth a 1))
    ~zod/try=> (skim (limo [0 1 2 3 ~]) a)
    [i=2 t=[i=3 t=~]]

------------------------------------------------------------------------

### `++skip`

Except

    ++  skip                                                ::  except
      ~/  %skip
      |*  [a=(list) b=_|=(p=* .?(p))]
      |-
      ^+  a
      ?~  a  ~
      ?:((b i.a) $(a t.a) [i.a $(a t.a)])

Cycles through the members of a list `a`, passing them to a gate `b` and
producing a list of all of the members that produce `%.n`. Inverse of
`++skim`.

`a` is a [list]().

`b` is a [gate]() that accepts one argument and produces a loobean.

    ~zod/try=> =a |=(a=@ (gth a 1))
    ~zod/try=> (skip (limo [0 1 2 3 ~]) a)
    [i=0 t=[i=1 t=~]]

------------------------------------------------------------------------

### `++scag`

Prefix

    ++  scag                                                ::  prefix
      ~/  %scag
      |*  [a=@ b=(list)]
      |-  ^+  b
      ?:  |(?=(~ b) =(0 a))  ~
      [i.b $(b t.b, a (dec a))]

Accepts an atom `a` and list `b`, producing the first `a` elements of
the front of the list.

`a` is an [atom]().

`b` is a [list]().

    ~zod/try=> (scag 2 (limo [0 1 2 3 ~]))
    [i=0 t=[i=1 t=~]]
    ~zod/try=> (scag 10 (limo [1 2 3 4 ~]))
    [i=1 t=[i=2 t=[i=3 t=[i=4 t=~]]]]

------------------------------------------------------------------------

### `++slag`

Suffix

    ++  slag                                                ::  suffix
      ~/  %slag
      |*  [a=@ b=(list)]
      |-  ^+  b
      ?:  =(0 a)  b
      ?~  b  ~
      $(b t.b, a (dec a))

Accepts an atom `a` and list `b`, producing the remaining elements from
`b` starting at `a`.

`a` is an [atom]().

`b` is a [list]().

    ~zod/try=> (slag 2 (limo [1 2 3 4 ~]))
    [i=3 t=[i=4 t=~]]
    ~zod/try=> (slag 1 (limo [1 2 3 4 ~]))
    [i=2 t=[i=3 t=[i=4 t=~]]]

------------------------------------------------------------------------

### `++snag`

Index

    ++  snag                                                ::  index
      ~/  %snag
      |*  [a=@ b=(list)]
      |-
      ?~  b
        ~|('snag-fail' !!)
      ?:  =(0 a)  i.b
      $(b t.b, a (dec a))

Accepts an atom `a` and a list `b`, producing the element at the index
of `a`and failing if the list is null. Lists are 0-indexed.

`a` is an [atom]().

`b` is a [list]().

    ~zod/try=> (snag 2 "asdf")
    ~~d
    ~zod/try=> (snag 0 `(list ,@ud)`~[1 2 3 4])
    1

------------------------------------------------------------------------

### `++sort`

Quicksort

    ++  sort                                                ::  quicksort
      ~/  %sort
      |*  [a=(list) b=$+([* *] ?)]
      =>  .(a ^.(homo a))
      |-  ^+  a
      ?~  a  ~
      %+  weld
        $(a (skim t.a |=(c=_i.a (b c i.a))))
      ^+  t.a
      [i.a $(a (skim t.a |=(c=_i.a !(b c i.a))))]

Quicksort: accepts a list `a` and a gate `b` which accepts two nouns and
produces a loobean. `++sort` then produces a list of the elements of `a`
sorted according to `b`.

`a` is an [atom]().

`b` is a [gate]() which accepts two nouns and produces a loobean.

        ~zod/try=> =a =|([p=@ q=@] |.((gth p q)))
        ~zod/try=> (sort (limo [0 1 2 3 ~]) a)
        ~[3 2 1 0]

------------------------------------------------------------------------

### `++swag`

Infix

    ++  swag                                                ::  infix
      |*  [[a=@ b=@] c=(list)]
      (scag b (slag a c))

Similar to `substr` in Javascript: extracts a string infix, beginning at
inclusive index `a`, producing `b` number of characters.

`a` and `b` are [atom]()s.

`c` is a [list]().

    ~zod/try=> (swag [2 5] "roly poly")
    "ly po"
    ~zod/try=> (swag [2 2] (limo [1 2 3 4 ~]))
    [i=3 t=[i=4 t=~]]

------------------------------------------------------------------------

### `++turn`

Gate to list

    ++  turn                                                ::  transform
      ~/  %turn
      |*  [a=(list) b=_,*]
      |-
      ?~  a  ~
      [i=(b i.a) t=$(a t.a)]

Accepts a list `a` and a gate `b`. Produces a list with the gate applied
to each element of the original list.

`a` is a [list]().

`b` is a [gate]().

    ~zod/try=> (turn (limo [104 111 111 110 ~]) ,@t)
    <|h o o n|>
    ~zod/try=> =a |=(a=@ (add a 4))
    ~zod/try=> (turn (limo [1 2 3 4 ~]) a)
    ~[5 6 7 8]

------------------------------------------------------------------------

### `++weld`

Concatenate

    ++  weld                                                ::  concatenate
      ~/  %weld
      |*  [a=(list) b=(list)]
      =>  .(a ^.(homo a), b ^.(homo b))
      |-  ^+  b
      ?~  a  b
      [i.a $(a t.a)]

Concatenate two lists `a` and `b`.

`a` and `b` are [list]()s.

    ~zod/try=> (weld "urb" "it")
    ~[~~u ~~r ~~b ~~i ~~t]
    ~zod/try=> (weld (limo [1 2 ~]) (limo [3 4 ~]))
    ~[1 2 3 4]

------------------------------------------------------------------------

### `++welp`

Perfect weld

    ++  welp                                                ::  perfect weld
      =|  [* *]
      |%
      +-  $
        ?~  +<-
          +<-(. +<+)
        +<-(+ $(+<- +<->))
      --

Concatenate two lists `a` and `b` without losing their type information
to homogenization.

`a` and `b` are [list]()s.

    ~zod/try=> (welp "foo" "bar")
    "foobar"
    ~zod/arvo=/hoon/hoon> (welp ~[60 61 62] ~[%a %b %c])
    [60 61 62 %a %b %c ~]
    ~zod/arvo=/hoon/hoon> :type; (welp ~[60 61 62] ~[%a %b %c])
    [60 61 62 %a %b %c ~]
    [@ud @ud @ud %a %b %c %~]
    ~zod/arvo=/hoon/hoon> (welp [sa/1 so/2 ~] si/3)
    [[%sa 1] [%so 2] %si 3]

------------------------------------------------------------------------

### `++wild`

XXDELETE

    ++  wild                                                ::  concatenate
      |*  [a=(list) b=(list)]
      =>  .(a ^.(homo a), b ^.(homo b))
      |-
      ?~  a  b
      [i=i.a $(a t.a)]

Concatenates two lists `a` and `b`, homogenizing their types
individually.

`a` and `b` are [list]()s.

    ~zod/try=> (wild (limo ~[1 2 3]) (limo [4]~))
    ~[1 2 3 4]
    ~zod/try=> (wild (limo 60 61 62 ~) (limo %a %b %c ~))
    [i=60 [i=61 [i=62 ~[%a %b %c]]]]
    ~zod/try=> (weld (limo 60 61 62 ~) (limo %a %b %c ~))
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.000 15].[10.016 57]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.001 15].[10.016 57]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.002 15].[10.016 57]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.004 15].[10.016 57]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.006 15].[10.016 57]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.006 29].[10.006 44]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.056 3].[10.061 13]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.058 3].[10.061 13]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.059 3].[10.061 13]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[10.060 5].[10.060 47]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.826 7].[9.844 35]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.827 7].[9.844 35]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.827 11].[9.838 13]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.828 11].[9.838 13]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.829 13].[9.831 47]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.830 13].[9.831 47]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.706 7].[9.712 25]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.707 7].[9.712 25]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.708 7].[9.712 25]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.712 7].[9.712 25]>
    ! /~zod/arvo/~2014.10.2..22.58.23..5af9/hoon/:<[9.712 8].[9.712 25]>
    ! exit

------------------------------------------------------------------------

### `++zing`

Cons

    ++  zing                                                ::  promote
      =|  *
      |%
      +-  $
        ?~  +<
          +<
        (welp +<- $(+< +<+))
      --

Turns a list of lists into a single list by promoting the elements of
each sublist into the higher.

Accepts a [list]() of lists.

    ~zod/try=> (zing (limo [(limo ['a' 'b' 'c' ~]) (limo ['e' 'f' 'g' ~]) (limo ['h' 'i' 'j' ~]) ~]))
    ~['a' 'b' 'c' 'e' 'f' 'g' 'h' 'i' 'j']
    ~zod/try=> (zing (limo [(limo [1 'a' 2 'b' ~]) (limo [3 'c' 4 'd' ~]) ~]))
    ~[1 97 2 98 3 99 4 100]