The list object holds a sequence of values in some arbitrary order. It offers all the operations necessary to support a stack, a queue, a deque, or a mutable array.
The bracket syntax yields a new list from some values:
var foo = [1, 2, 3, "hello", "world"]
The list is a container, so it offers basic information about its contents:
function size – number of items in the list
function empty? – true if the list is empty, false if it contains at least one value
The list is a sequence, so you can iterate over its contents:
function iterate – returns an iterator which points at item zero, if it exists, or is invalid, if the list is empty
The list can reverse itself in constant time, by inverting the sense of all of its methods:
method reverse – exchanges all items in the list, so the head becomes the tail and vice versa
Access to the beginning and end of the list is particularly efficient, so these functions and methods work in amortized constant time:
method push(value) – insert a value before the current head, becoming the new head
method pop – remove the head value, or raise an exception if the list is empty
function head – return the beginning element of the list, or raise an exception if the list is empty
method append – insert a new value after the current tail, becoming the new tail
method chop – remove the tail value, or raise an exception if the list is empty
function tail – return the value at the tail of the list, or raise an exception if the list is empty
The list allows random access to any element by index, which counts from zero. These functions and methods work in logarithmic time:
list[index] – the subscript operation looks up the value with the specified index, or returns an exception if out of bounds
method assign(index, value) – replace the value at the specified index with a new value
method insert(index, value) – insert a new value at the specified index, pushing down the existing value
method remove(index) – remove the value at the specified index, popping up the values which follow it
One can also cut and splice entire arrays:
function partition(index) – returns a pair of lists (as a 2-tuple); the first contains all items before the specified index, and the second contains the specified item and all items which follow. If the index equals zero, or equals the size of the list, one of the lists returned will be empty
method concatenate(list) – appends all of the items on the parameter list to the first list. If the parameter is actually a list object, this is an efficient O(log n) operation; if the parameter is not a list, but is a sequence, this is an O(n) operation on the number of items in the parameter.