Sequences are collections with nonnegative integer keys.
| <seq> | (<col>) | C | 
| <seq.> | (<seq> <col.>) | C | 
|  | immutable sequence. |  | 
| 1st | (x|<seq> => <any>) | G | 
|  | ==  (elt x 0) |  | 
| 2nd | (x|<seq> => <any>) | G | 
|  | ==  (elt x 1) |  | 
| 3rd | (x|<seq> => <any>) | G | 
|  | ==  (elt x 2) |  | 
| last | (x|<seq> => <any>) | G | 
|  | ==  (elt x (- (len x) 1)) |  | 
| pos | (x|<seq> v|<any> => (t? <int>)) | G | 
|  | finds position of v in x else returns false. |  | 
| finds | (x|<seq> y|<seq> => (t? <int>)) | G | 
|  | finds position of y in x else returns false. |  | 
| add | (x|<seq> y|<any> => <seq>) | M | 
|  | returns sequence with y added to the end of x. |  | 
| push | (x|<seq> y|<any> => <seq>) | G | 
|  | returns sequence with y added to x. |  | 
| pop | (x|<seq> => (tup <any> <seq>)) | G | 
|  | returns last pushed element of x and new sequence with that
       element removed from x. |  | 
| rev | (x|<seq> => <seq>) | G | 
|  | returns reversed sequence. |  | 
| cat | (x|<seq> more|... => <seq>) | G | 
|  | returns concatenated sequences. |  | 
| sub | (x|<seq> from|<int> below|<int> => <seq>) | G | 
|  | subsequence of x between from and below. |  | 
| '[' ... ']' | '[' ,x ,from ,below ']' | S | 
|  | ==  (sub ,x ,from ,below) |  | 
| sub* | (x|<seq> from|<int> => <seq>) | G | 
|  | ==  (sub x from (len x)) |  | 
| '[' ... ']' | '[' ,x ,from * ']' | S | 
|  | ==  (sub* ,x ,from) |  | 
| ins | (x|<seq> val i|<int> => <seq>) | G | 
|  | returns copy of x's with val inserted before i. |  | 
| del-dups | (x|<seq> => <seq>) | G | 
|  | returns sequence with all duplicates removed. |  | 
| del-vals | (s|<seq> val => <seq>) | G | 
|  | returns sequence with all copies of val removed. |  | 
| sort-by | (s|<seq> f|<fun> => <seq>) | G | 
|  | returns a sorted copy of s using f as a comparator. |  | 
| sort | (s|<seq> => <seq>) | G | 
|  | ==  (sort-by s <) |  | 
| pick | (f|<fun> x|<seq> => <seq>) | G | 
|  | returns new sequence with elements corresponding to 
  non-false results when calling predicate f. |  | 
| prefix? | (x|<seq> prefix|<seq> => <log>) | G | 
|  | returns true iff sequence x starts with sequence prefix. |  | 
| suffix? | (x|<seq> suffix|<seq> => <log>) | G | 
|  | returns true iff sequence x ends with sequence suffix. |  | 
| repeat | (x|<seq> n|<int> => <seq>) | G | 
|  | returns sequence with n concatenated copies of x. |  | 
| split | (x|<seq> sep => <seq>) | G | 
|  | returns sequence of subsequences of x separated by sep. |  | 
| join | (xs|<seq> sep|<seq> => <seq>) | G | 
|  | returns sequence composed of sequences in xs joined with
  sep. |  | 
|  | 
| <seq!> | (<seq> <col!>) | C | 
| rev! | (x|<seq!> => <seq!>) | G | 
|  | returns destructively reversed sequence. |  | 
| cat! | (x|<seq!> more|... => <seq!>) | G | 
|  | returns destructively concatenated sequences. |  | 
| add! | (x|<seq!> y|<any> => <seq!>) | G | 
|  | returns collection with y added to the end of x. |  | 
| push! | (x|<seq!> y|<any> => <seq!>) | G | 
|  | returns collection with y added to the front of x. |  | 
| pop! | (x|<seq!> => (tup val|<any> <seq!>)) | G | 
|  | pops element from front of sequence. |  | 
| PUSHF | (PUSHF ,place ,val) | S | 
|  | pushes ,val onto the sequence stored in ,place,
  updates ,place to contain the new sequence, and returns the new
  sequence. |  | 
| POPF | (POPF ,place) | S | 
|  | pops a value from the sequence stored in 
  ,place, replaces
  the sequence with an updated sequence, and returns the value. |  | 
| ins! | (x|<seq!> v|<any> i|<int> => <seq!>) | G | 
|  | inserts v before i in x. |  | 
| sub-setter | (dst|<seq!> src|<seq> from|<int> below|<int>) | G | 
|  | replaces subsequence in range between from and
  below of dst with
  contents of src.  Provides insertion, deletion, and
  replacement operations rolled into one. |  | 
| sub*-setter | (dst|<seq!> src|<seq> from|<int>) | G | 
|  | ==  (sub-setter dst src from (len dst)) |  | 
| del-vals! | (x|<seq!> v|<any>  => <seq!>) | G | 
|  | removes all v's from x. |  | 
| del-dups! | (x|<seq!> => <seq!>) | G | 
|  | removes all duplicates from x. |  | 
| sort-by! | (s|<seq> f|<fun> => <seq>) | G | 
|  | destructively sorts s using f as a comparator. |  | 
| sort! | (s|<seq> => <seq>) | G | 
|  | ==  (sort-by! s <) |  | 
|  | 
 
Lists are always "proper" lists, that is, the tail of a list is always a
list.  Lists might be deprecated in future releases of GOO.
A zip is a sequence of tuples of sucessive elements of sequences.  A
zip has the length of its shortest constituent sequence.
Flats represents sequences with constant access time.  Flat enum provides
an enum implementation of all but now and now-setter.