|
<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.
|
<lst> | (<seq!>) | C |
|
<list> | <lst> | A |
|
head | (x|<lst> => <any>) | P |
|
tail | (x|<lst> => <lst>) | P |
|
lst | (elts|... => <lst>) | G |
|
| returns list of arguments. | |
|
list | lst | A |
|
nil | <lst> | I |
|
| aka (). | |
|
pair | (x|<any> y|<lst> => <lst>) | G |
|
| returns new list with x as head and y as tail. | |
|
|
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.
