Cons[A: A]¶

A list with a head and a tail, where the tail can be empty.

class val Cons[A: A] is
  ReadSeq[val->A] box

Implements¶

ReadSeq[val->A] box

Constructors¶

create¶

[Source]

new val create(
  a: val->A,
  t: (Cons[A] val | Nil[A] val))
: Cons[A] val^

Parameters¶

a: val->A
t: (Cons[A] val | Nil[A] val)

Returns¶

Cons[A] val^

Public Functions¶

size¶

[Source]

Returns the size of the list.

fun box size()
: USize val

Returns¶

USize val

apply¶

[Source]

Returns the i-th element of the list. Errors if the index is out of bounds.

fun box apply(
  i: USize val)
: val->A ?

Parameters¶

i: USize val

Returns¶

val->A ?

values¶

[Source]

Returns an iterator over the elements of the list.

fun box values()
: Iterator[val->A] ref^

Returns¶

Iterator[val->A] ref^

is_empty¶

[Source]

Returns a Bool indicating if the list is empty.

fun box is_empty()
: Bool val

Returns¶

Bool val

is_non_empty¶

[Source]

Returns a Bool indicating if the list is non-empty.

fun box is_non_empty()
: Bool val

Returns¶

Bool val

head¶

[Source]

Returns the head of the list.

fun box head()
: val->A

Returns¶

val->A

tail¶

[Source]

Returns the tail of the list.

fun box tail()
: (Cons[A] val | Nil[A] val)

Returns¶

(Cons[A] val | Nil[A] val)

reverse¶

[Source]

Builds a new list by reversing the elements in the list.

fun val reverse()
: (Cons[A] val | Nil[A] val)

Returns¶

(Cons[A] val | Nil[A] val)

prepend¶

[Source]

Builds a new list with an element added to the front of this list.

fun val prepend(
  a: val->A!)
: Cons[A] val

Parameters¶

a: val->A!

Returns¶

Cons[A] val

concat¶

[Source]

Builds a new list that is the concatenation of this list and the provided list.

fun val concat(
  l: (Cons[A] val | Nil[A] val))
: (Cons[A] val | Nil[A] val)

Parameters¶

l: (Cons[A] val | Nil[A] val)

Returns¶

(Cons[A] val | Nil[A] val)

map[B: B]¶

[Source]

Builds a new list by applying a function to every member of the list.

fun val map[B: B](
  f: {(val->A): val->B}[A, B] box)
: (Cons[B] val | Nil[B] val)

Parameters¶

f: {(val->A): val->B}[A, B] box

Returns¶

(Cons[B] val | Nil[B] val)

flat_map[B: B]¶

[Source]

Builds a new list by applying a function to every member of the list and using the elements of the resulting lists.

fun val flat_map[B: B](
  f: {(val->A): List[B]}[A, B] box)
: (Cons[B] val | Nil[B] val)

Parameters¶

f: {(val->A): List[B]}[A, B] box

Returns¶

(Cons[B] val | Nil[B] val)

for_each¶

[Source]

Applies the supplied function to every element of the list in order.

fun val for_each(
  f: {(val->A)}[A] box)
: None val

Parameters¶

f: {(val->A)}[A] box

Returns¶

None val

filter¶

[Source]

Builds a new list with those elements that satisfy a provided predicate.

fun val filter(
  f: {(val->A): Bool}[A] box)
: (Cons[A] val | Nil[A] val)

Parameters¶

f: {(val->A): Bool}[A] box

Returns¶

(Cons[A] val | Nil[A] val)

fold[B: B]¶

[Source]

Folds the elements of the list using the supplied function.

fun val fold[B: B](
  f: {(B, val->A): B^}[A, B] box,
  acc: B)
: B

Parameters¶

f: {(B, val->A): B^}[A, B] box
acc: B

Returns¶

B

every¶

[Source]

Returns true if every element satisfies the provided predicate, false otherwise.

fun val every(
  f: {(val->A): Bool}[A] box)
: Bool val

Parameters¶

f: {(val->A): Bool}[A] box

Returns¶

Bool val

exists¶

[Source]

Returns true if at least one element satisfies the provided predicate, false otherwise.

fun val exists(
  f: {(val->A): Bool}[A] box)
: Bool val

Parameters¶

f: {(val->A): Bool}[A] box

Returns¶

Bool val

partition¶

[Source]

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 val partition(
  f: {(val->A): Bool}[A] box)
: ((Cons[A] val | Nil[A] val) , (Cons[A] val | Nil[A] val))

Parameters¶

f: {(val->A): Bool}[A] box

Returns¶

((Cons[A] val | Nil[A] val) , (Cons[A] val | Nil[A] val))

drop¶

[Source]

Builds a list by dropping the first n elements.

fun val drop(
  n: USize val)
: (Cons[A] val | Nil[A] val)

Parameters¶

n: USize val

Returns¶

(Cons[A] val | Nil[A] val)

drop_while¶

[Source]

Builds a list by dropping elements from the front of the list until one fails to satisfy the provided predicate.

fun val drop_while(
  f: {(val->A): Bool}[A] box)
: (Cons[A] val | Nil[A] val)

Parameters¶

f: {(val->A): Bool}[A] box

Returns¶

(Cons[A] val | Nil[A] val)

take¶

[Source]

Builds a list of the first n elements.

fun val take(
  n: USize val)
: (Cons[A] val | Nil[A] val)

Parameters¶

n: USize val

Returns¶

(Cons[A] val | Nil[A] val)

take_while¶

[Source]

Builds a list of elements satisfying the provided predicate until one does not.

fun val take_while(
  f: {(val->A): Bool}[A] box)
: (Cons[A] val | Nil[A] val)

Parameters¶

f: {(val->A): Bool}[A] box

Returns¶

(Cons[A] val | Nil[A] val)