Mutable_Linked_List

append an element to the linked list

collect the contents of this Sequence into an array

create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.

returns Sequence.this if is_array_backed.

return this linked list as a list

convenience feature to work around type inference issues
NYI remove when type inference gets better

a representation of this linked list as a string.

create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.

NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.

create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.

NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.

call 'as_string' on the elements

create a new list that contains the first elements of
this Sequence for which 'f e' is false

chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.

create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows

Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last

append an entire list to this linked list

create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s

count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list

For lists that are not array backed, this might require time in O(count).

create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'

create a list that consists of the elements of this Sequence except the first
n elements

NOTE: this may have performance in O(n) unless it is backed by an immutable array.

Lazily drop the first elements of this Sequence for which predicate 'p' holds.

Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.

There is no dynamic type of a type instance since this would result in an
endless hierachy of types. So for Type values, dynamic_type is redefined
to just return Type.type.

filter elements using predicate f
values for which f is false are dropped

is this sequence known to be finite? For infinite sequences, features like
count diverge.

get the first element of this Sequence

Sequence must not be empty, causes precondition failure if debug is enabled.

get the first element of this Sequence or default if sequence is empty

map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.

fold the elements of this Sequence using the given monoid.

e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum

fold the elements of this non-empty Sequence using the given function

e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`

fold the elements of this Sequence using the given function and initial
value.

In case this Sequence is empty, the result is `e`.

e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`

create a list and call 'for_each f' on it

apply 'f' to each element 'e' as long as 'f e'

freeze this list, i.e., turn all references into immutable values

group the elements of this sequence by a key of type K

f determines the key of an element

get a function that, given an index, returns the element at that index

the nth element in the sequence, must exist

adds the corresponding index to
every element in the sequence

adds an index to every element
in the sequence starting at start_idx

consume all elements of this Sequence by f. This is an infix operator alias
for for_each.

Ex.: To print all the elements of a list, you can use

1..10 ! say

filter elements using predicate f, infix operator
synonym of filter.

NYI: What is better, 'infix |&' or 'infix &', or something else?

infix operand synonym for concat_sequences

map the Sequence to a new Sequence applying function f to all elements

This is an infix operator alias of map enabling piping code like

l := 1..10 | *10 | 300-

to obtain 290,280,270,...200

Note that map and therefore also this operator is lazy, so

_ := (1..10 | say)

will not print anything while

(1..10 | say).for_each _->unit

will print the elements since `for_each` is not lazy.

filter elements using predicate f, infix operator
synonym of filter.

check if predicate f holds for all elements

check if predicate f holds for at least one element

insert element v at position at

apply transducer to sequence, returning a sequence of results

example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]

is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.

is this Sequence empty?

check if argument is a valid index in this sequence.

Note that this may have a performance in O(i) unless this
Sequence is_array_backed.

get the last element of this Sequence

Sequence must not be empty, causes precondition failure if debug is enabled.

This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.

get the last element of this Sequence or default if sequence is empty

map the Sequence to a new Sequence applying function f to all elements

This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.

Map this Sequence to f applied to neighboring pairs of values
in this Sequence.

In case this Sequence has less than two elements, the result will
be the empty list.

ex. to obtain a list of differences you, you may use `map_pairs (-)`:

[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a

results in `[1,2,2,4,2,4,2,4,6]`

name of this type, including type parameters, e.g. 'option (list i32)'.

short-hand features to get the mutable references from `n`

the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.

Complexity: if Sequence is array backed O(1) otherwise O(n)

create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows

(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)

calls `f` for element in the Sequence.

Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.

example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10

convenience prefix operator to create a string from a value.

This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.

reduce this Sequence to R with an initial value init
and a reducing function f.
the reduction is finished once f yields abort or
if the end of the sequence is reached.

reduce this Sequence to `outcome R`
with an initial value `init` and a reducing function `f`.
the reduction is finished once `f` yields `abort` or
if the end of the sequence is reached.

reverse the order of the elements in this Sequence

map this Sequence to a list that contains the result of folding
all prefixes using the given monoid.

e.g., for a Sequence of i32 s, s.scan i32.sum creates a list of
partial sums (0..).map x->(s.take x).fold i32.sum

create a slice from this Sequence that consists of the elements starting at index
from (including) up to index to (excluding).

sort this Sequence using the total order defined by less_or_equal

sort this Sequence using total order defined for 'f a[i]'

create a tuple of two Sequences by splitting this at the given index, i.e.,
a Sequence of length 'at' and one of length 'count-at'.

at may be <= 0 or >= count, in which case the resulting tuple will be the
(empty list, Sequence.this.as_list) or (Sequence.this.as_list, empty list), resp.

create a lazy list of all the tails of this Sequence, including the complete Sequence
as a list and the empty list 'nil'.

create a list that consists only of the first n elements of this
Sequence, fewer if this Sequence has fewer elements

Lazily take the first elements of this Sequence for which predicate 'p' holds.

takes a transducer xf, a reducer f and an initial value
returns the result of applying the reducer xf f to the Sequence

create a new list from the result of applying 'f' to the
elements of this Sequence and 'b' in order.

Maximum number of elements shown for on a call to `as_string` for a non-finite
Sequence.

monoid of Sequences with infix concatentation operation.

create a mutable linked list from a given sequence

this results in a mutable linked list that is not yet frozen, i.e. it
can still be modified. however, the list needs to be frozen manually
before leaving the mutate environment.

create a mutable linked list from a given sequence

the argument freeze specifies whether the resulting list is frozen. if
true, the list is frozen after creation, i.e. it can no longer be changed,
but the mutate environment can be left.

Get a type as a value.

This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.

`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.