← empty ideal • runtime • elements • base readonly list base list →
A list is an ordered sequence of values.
class base readonly list[value element type]
Declaration: base readonly list
Announcements: base readonly list
Direct supertypes: list
All supertypes: collection / composite value / value / entity
namespace parameters
Declaration: parameters
Use: base readonly list
Wrapper of an array that implements on-demand resizing and copy-on-write semantics. The same list_state can be shared by multiple instances of base_readonly_lists.
protected class list state[value element type]
Declaration: list state
All supertypes: value / entity
Use: base readonly list / base readonly list / list state / list state / list state / list state / base list / base list / base immutable list / base immutable list / base immutable list
import ideal • machine • elements • array
Specifies whether this instance of list_state is writable. A single non-writable copy can be shared among multiple instances of base_readonly_list.
var boolean writable
Declaration: writable
Use: base readonly list / base readonly list / base readonly list / base readonly list
Construct a list state with an array of specified size.
overload list state(nonnegative initial size)
Declaration: constructor
Construct a list state with an array of default size.
overload list state()
Declaration: constructor
Construct a list state from a given array of elements. Assumes noone mutates the elements.
overload list state(array[element type] immutable elements)
Declaration: constructor
Make sure the array is of at least the specified size.
void reserve(nonnegative reserve size)
Declaration: reserve
Use: base readonly list
Insert elements at the specified index.
void insert all(nonnegative index, readonly list[element type] new elements)
Declaration: insert all
Insert an element at the specified index.
void insert(nonnegative index, element type element)
Declaration: insert
Use: base readonly list
Helper method used to create space in the middle of an array.
private void reserve and move(nonnegative index, nonnegative extra size)
Declaration: reserve and move
Use: base readonly list / base readonly list
void clear(nonnegative begin, nonnegative length)
Declaration: clear
list state[element type] copy()
Declaration: copy
protected var list state[element type] state
Declaration: state
Use: state / state / state / state / state / state / state / state / state / state / state / state / state / state
protected overload base readonly list()
Declaration: constructor
protected overload base readonly list(list state[element type] state)
Declaration: constructor
The number of elements in the collection.
implement nonnegative size
Declaration: size
Direct overrides: size
Use: size / size
Specifies whether the collection has zero elements.
implement boolean is empty
Declaration: is empty
Direct overrides: is empty
Specifies whether the collection has more than zero elements. Shortcut for !is_empty.
implement boolean is not empty
Declaration: is not empty
Direct overrides: is not empty
Use: is not empty / is not empty
Access the first element of the list. Assumes the list is not empty.
implement element type first()
Declaration: first
Direct overrides: first
Access the last element of the list. Assumes the list is not empty.
implement element type last()
Declaration: last
Direct overrides: last
Read the list's element for the specified index.
implement implicit readonly reference[element type] get(nonnegative index) pure
Declaration: constructor
Direct overrides: list
Enumerates elements in some collection-defined order. This method returns a snapshot of the collection state, so subsequent mutations of the collection do not cause changes in the returned list.
implement immutable list[element type] elements()
Declaration: elements
Direct overrides: elements
Returns an immutable copy of this list.
implement immutable list[element type] frozen copy()
Declaration: frozen copy
Direct overrides: list
Directly overriden by: base immutable list
Returns an immutable sublist with the given the starting and ending indices.
The starting index is inclusive, the ending is exclusive.
implement immutable list[element type] slice(nonnegative begin, nonnegative end)
Declaration: slice
Direct overrides: list
Skips over the specified count of elements and returns an immutable slice that begins with count and ends with the end of this list.
implement immutable list[element type] skip(nonnegative count)
Declaration: skip
Direct overrides: list
Check whether the list has at least one element that satisfies the predicate.
implement boolean has(predicate[element type] the predicate) pure
Declaration: has
Direct overrides: list
← empty ideal • runtime • elements • base readonly list base list →