<i>GOO Manual -- Sequences

Sequences

Sequences

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.

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.

Mutable Sequences

`<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.
`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

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.

Zips

A zip is a sequence of tuples of sucessive elements of sequences. A zip has the length of its shortest constituent sequence.
<zip> (<seq.>) C

zip (cs|(... <seq>) => <zip>) G

returns a zip over sequences cs.

unzip (z|<zip> => <tup>) G

returns a tuple of z's constituent sequences.

Flat Sequences

Flats represents sequences with constant access time. Flat enum provides an enum implementation of all but now and now-setter.
<flat> (<seq>) C

<flat-enum> (<enum>) C

<tup> (<flat> <seq.>) C

Tuples are immutable flat sequences and represents multiple values in GOO.

tup (elts|... => <tup>) G

creates a tuple with elements being elts.

<vec> (<flat> <seq!>) C

Stretchy vectors resize when needed.

vec (elts|... => <sec>) G

returns new vector with elements elts.

Strings

GOO currently implements ASCII strings.
<str> (<flat> <mag> <seq.>) C

str (elts|... => <str>) G

returns new string with elements elts.

case-insensitive-string-hash (x|<tab> => (tup hash|<any> gc-state|<any>)) G

case-insensitive-string-equal (x|<str> y|<str> => <log>) G

Sequences

`<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`.
`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`.

`<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.

`<zip>`	`(<seq.>)`	`C`
`zip`	`(cs\|(... <seq>) => <zip>)`	`G`
	returns a zip over sequences `cs`.
`unzip`	`(z\|<zip> => <tup>)`	`G`
	returns a tuple of `z`'s constituent sequences.

`<flat>`	`(<seq>)`	`C`
`<flat-enum>`	`(<enum>)`	`C`
`<tup>`	`(<flat> <seq.>)`	`C`
	Tuples are immutable flat sequences and represents multiple values in GOO.
`tup`	`(elts\|... => <tup>)`	`G`
	creates a tuple with elements being `elts`.
`<vec>`	`(<flat> <seq!>)`	`C`
	Stretchy vectors resize when needed.
`vec`	`(elts\|... => <sec>)`	`G`
	returns new vector with elements `elts`.

`<str>`	`(<flat> <mag> <seq.>)`	`C`
`str`	`(elts\|... => <str>)`	`G`
	returns new string with elements `elts`.
`case-insensitive-string-hash`	`(x\|<tab> => (tup hash\|<any> gc-state\|<any>))`	`G`
`case-insensitive-string-equal`	`(x\|<str> y\|<str> => <log>)`	`G`