List [Src] [A: A]
A doubly linked list.
class ref List[A: A] is
Seq[A] ref
Implements
- Seq[A] ref
Constructors
create [Src]
new ref create(
len: USize val = seq)
: List[A] ref^
Parameters
- len: USize val = seq
Returns
- List[A] ref^
unit [Src]
new ref unit(
a: A)
: List[A] ref^
Parameters
- a: A
Returns
- List[A] ref^
from [Src]
new ref from(
seq: Array[A^] ref)
: List[A] ref^
Parameters
- seq: Array[A^] ref
Returns
- List[A] ref^
Public Functions
reserve [Src]
Do nothing, but be compatible with Seq.
fun ref reserve(
len: USize val)
: None val
Parameters
- len: USize val
Returns
- None val
size [Src]
Returns the number of items in the list.
fun box size()
: USize val
Returns
- USize val
apply [Src]
Get the i-th element, raising an error if the index is out of bounds.
fun box apply(
i: USize val = seq)
: this->A ?
Parameters
- i: USize val = seq
Returns
- this->A ?
update [Src]
Change the i-th element, raising an error if the index is out of bounds. Returns the previous value, which may be None if the node has been popped but left on the list.
fun ref update(
i: USize val,
value: A)
: A^ ?
Parameters
- i: USize val
- value: A
Returns
- A^ ?
index [Src]
Gets the i-th node, raising an error if the index is out of bounds.
fun box index(
i: USize val)
: this->ListNode[A] ref ?
Parameters
- i: USize val
Returns
- this->ListNode[A] ref ?
remove [Src]
Remove the i-th node, raising an error if the index is out of bounds. The removed node is returned.
fun ref remove(
i: USize val)
: ListNode[A] ref ?
Parameters
- i: USize val
Returns
- ListNode[A] ref ?
clear [Src]
Empties the list.
fun ref clear()
: None val
Returns
- None val
head [Src]
Get the head of the list.
fun box head()
: this->ListNode[A] ref ?
Returns
- this->ListNode[A] ref ?
tail [Src]
Get the tail of the list.
fun box tail()
: this->ListNode[A] ref ?
Returns
- this->ListNode[A] ref ?
prepend_node [Src]
Adds a node to the head of the list.
fun ref prepend_node(
node: ListNode[A] ref)
: None val
Parameters
- node: ListNode[A] ref
Returns
- None val
append_node [Src]
Adds a node to the tail of the list.
fun ref append_node(
node: ListNode[A] ref)
: None val
Parameters
- node: ListNode[A] ref
Returns
- None val
append_list [Src]
Remove all nodes from that and append them to this.
fun ref append_list(
that: List[A] ref)
: None val
Parameters
- that: List[A] ref
Returns
- None val
prepend_list [Src]
Remove all nodes from that and prepend them to this.
fun ref prepend_list(
that: List[A] ref)
: None val
Parameters
- that: List[A] ref
Returns
- None val
push [Src]
Adds a value to the tail of the list.
fun ref push(
a: A)
: None val
Parameters
- a: A
Returns
- None val
pop [Src]
Removes a value from the tail of the list.
fun ref pop()
: A^ ?
Returns
- A^ ?
unshift [Src]
Adds a value to the head of the list.
fun ref unshift(
a: A)
: None val
Parameters
- a: A
Returns
- None val
shift [Src]
Removes a value from the head of the list.
fun ref shift()
: A^ ?
Returns
- A^ ?
append [Src]
Append len elements from a sequence, starting from the given offset.
fun ref append(
seq: (ReadSeq[A] box & ReadElement[A^] box),
offset: USize val = seq,
len: USize val = seq)
: None val
Parameters
- seq: (ReadSeq[A] box & ReadElement[A^] box)
- offset: USize val = seq
- len: USize val = seq
Returns
- None val
concat [Src]
Add len iterated elements to the end of the list, starting from the given offset.
fun ref concat(
iter: Iterator[A^] ref,
offset: USize val = seq,
len: USize val = seq)
: None val
Parameters
Returns
- None val
truncate [Src]
Truncate the list to the given length, discarding excess elements. If the list is already smaller than len, do nothing.
fun ref truncate(
len: USize val)
: None val
Parameters
- len: USize val
Returns
- None val
clone [Src]
Clone the list.
fun box clone()
: List[this->A!] ref^
Returns
- List[this->A!] ref^
map [Src] [B: B]
Builds a new list by applying a function to every member of the list.
fun box map[B: B](
f: {(this->A!): B^}[A, B] box)
: List[B] ref^
Parameters
- f: {(this->A!): B^}[A, B] box
Returns
- List[B] ref^
flat_map [Src] [B: B]
Builds a new list by applying a function to every member of the list and using the elements of the resulting lists.
fun box flat_map[B: B](
f: {(this->A!): List[B]}[A, B] box)
: List[B] ref^
Parameters
- f: {(this->A!): List[B]}[A, B] box
Returns
- List[B] ref^
filter [Src]
Builds a new list with those elements that satisfy a provided predicate.
fun box filter(
f: {(this->A!): Bool}[A] box)
: List[this->A!] ref^
Parameters
- f: {(this->A!): Bool}[A] box
Returns
- List[this->A!] ref^
fold [Src] [B: B]
Folds the elements of the list using the supplied function.
fun box fold[B: B](
f: {(B!, this->A!): B^}[A, B] box,
acc: B)
: B
Parameters
- f: {(B!, this->A!): B^}[A, B] box
- acc: B
Returns
- B
every [Src]
Returns true if every element satisfies the provided predicate, false otherwise.
fun box every(
f: {(this->A!): Bool}[A] box)
: Bool val
Parameters
- f: {(this->A!): Bool}[A] box
Returns
- Bool val
exists [Src]
Returns true if at least one element satisfies the provided predicate, false otherwise.
fun box exists(
f: {(this->A!): Bool}[A] box)
: Bool val
Parameters
- f: {(this->A!): Bool}[A] box
Returns
- Bool val
partition [Src]
Builds a pair of lists, the first of which is made up of the elements satisfying the supplied predicate and the second of which is made up of those that do not.
fun box partition(
f: {(this->A!): Bool}[A] box)
: (List[this->A!] ref^ , List[this->A!] ref^)
Parameters
- f: {(this->A!): Bool}[A] box
Returns
drop [Src]
Builds a list by dropping the first n elements.
fun box drop(
n: USize val)
: List[this->A!] ref^
Parameters
- n: USize val
Returns
- List[this->A!] ref^
take [Src]
Builds a list of the first n elements.
fun box take(
n: USize val)
: List[this->A!] ref
Parameters
- n: USize val
Returns
- List[this->A!] ref
take_while [Src]
Builds a list of elements satisfying the provided predicate until one does not.
fun box take_while(
f: {(this->A!): Bool}[A] box)
: List[this->A!] ref^
Parameters
- f: {(this->A!): Bool}[A] box
Returns
- List[this->A!] ref^
reverse [Src]
Builds a new list by reversing the elements in the list.
fun box reverse()
: List[this->A!] ref^
Returns
- List[this->A!] ref^
contains [Src] [optional B: (A & HasEq[A!] #read)]
Returns true if the list contains the provided element, false otherwise.
fun box contains[optional B: (A & HasEq[A!] #read)](
a: box->B)
: Bool val
Parameters
- a: box->B
Returns
- Bool val
nodes [Src]
Return an iterator on the nodes in the list.
fun box nodes()
: ListNodes[A, this->ListNode[A] ref] ref^
Returns
rnodes [Src]
Return an iterator on the nodes in the list.
fun box rnodes()
: ListNodes[A, this->ListNode[A] ref] ref^
Returns
values [Src]
Return an iterator on the values in the list.
fun box values()
: ListValues[A, this->ListNode[A] ref] ref^
Returns
- ListValues[A, this->ListNode[A] ref] ref^
rvalues [Src]
Return an iterator on the values in the list.
fun box rvalues()
: ListValues[A, this->ListNode[A] ref] ref^
Returns
- ListValues[A, this->ListNode[A] ref] ref^