Container Types
===============

Apart from arrays and scopes, a few other container types are provided in the standard library.

Lists
-----

A list maps integers to arbitrary objects. Access to members takes time linear in the index.

A new list can be created with `list` and appended to with `append` or `append1` (the latter
will not distribute over domain having inputs).

    list ==l
    /a l .append
    /b l .append
    /c l .append
    l dump
    <scope: 0000600000533210>
    l |dump each
    "a"
    "b"
    "c"
    l len dump
    0000000000000003
    list ==m
    [ /a /b /c ] m .append1
    m len dump
    0000000000000001

Lists can be used similar to functions from integers or arrays. Just as with
arrays, negative indices start from the end of the list towards the beginning.
Write access is provided via `=[]` as usual.

    list ==l
    [ /a /b /c ] l .append
    0 l * dump
    "a"
    1 neg l * dump
    "c"
    l dom dump
    [
      0000000000000000
      0000000000000001
      0000000000000002
    ]
    /foo 1 l =[]
    l |dump each
    "a"
    "foo"
    "c"
    l l { cat } '*0.0 |dump each
    "aa"
    "bb"
    "cc"

List can be used like a stack via `pop`.

    list ==l
    [ /a /b /c ] l .append
    l .pop
    l |dump each
    "a"
    "b"

Maps
----

Maps wrap scopes to provide an array-like container mapping from strings to arbitrary objects.

A new map can be created with `map`, new members are added via `=[]` when the key does not exist
beforehand. Access to specific members works like in arrays via `*`. Testing for members can be
done via `has`.

    map ==m
    1 /foo m =[]
    2 /bar m =[]
    m dump
    <scope: 0000600000533210>
    m dom dump
    [
      "foo"
      "bar"
    ]
    m |dump each
    0000000000000001
    0000000000000002
    /foo m * dump
    0000000000000001
    /foo m .has dump
    0000000000000001
    /FOO m .has dump
    0000000000000000
    m 2 mul ==m2
    m2 dom dump
    [
      "foo"
      "bar"
    ]
    m2 |dump each
    0000000000000002
    0000000000000004
    /foo m2 * dump
    0000000000000002

Trees
-----

Trees provide mapping from keys to arbitrary objects,
keeping the keys in `lt`/`eq`/`gt` ascending order. Otherwise they should work just as maps.

    tree ==t
    1 /foo t =[]
    2 /bar t =[]
    t dump
    <scope: 0000600000533210>
    t dom dump
    [
      "bar"
      "foo"
    ]
    t |dump each
    0000000000000002
    0000000000000001
    /foo t * dump
    0000000000000001
    /foo t .has dump
    0000000000000001
    /FOO t .has dump
    0000000000000000
    t 2 mul ==t2
    t2 dom dump
    [
      "bar"
      "foo"
    ]
    t2 |dump each
    0000000000000004
    0000000000000002
    /foo t2 * dump
    0000000000000002