#root::data

Array root/data/Array.vi

struct Array[T](...);

A contiguous, indexed collection of T.

Values can be efficiently accessed by index, and added/removed from the beginning/end of the array.

Iterating over all of the values is less efficient; if this is being done regularly, consider using a List[T] instead.

empty root/data/Array.vi:14

const empty[T]: Array[T];

single root/data/Array.vi:16

fn single[T](value: T) -> Array[T];

new root/data/Array.vi:25

fn new[T; Fork[T], Drop[T]](len: N32, value: T) -> Array[T];

Create an array containing len copies of value.

Array::new(6, ".") // Array([".", ".", ".", ".", ".", "."])

from_list root/data/Array.vi:38

impl from_list[T]: Cast[List[T], Array[T]];

Convert a list to an array, preserving the order of values. O(n)

let array = [1, 2, 3] as Array;
array // Array([1, 2, 3])

to_list root/data/Array.vi:62

impl to_list[T]: Cast[Array[T], List[T]];

Convert a list to an array, preserving the order of values. O(n)

let array = Array::empty;
array.push_back(1);
array.push_back(2);
array.push_back(3);
array as List // [1, 2, 3]

from_fn root/data/Array.vi:76

fn from_fn[T, F; Fork[F], Drop[F], Fn[F, (), T]](len: N32, f: F) -> Array[T];

Create an array with the given length, where each value is produced in order by calling the function. O(n)

let i = 0;
let array = Array::from_fn(3, fn* () { i += 1; i });
array // Array([1, 2, 3])

for_each root/data/Array.vi:92

fn for_each[T, F; Fork[F], Drop[F], Fn[F, (T,), ()]](self: Array[T], f: F);

Iterate over the values of the array in order.

fold_front root/data/Array.vi:111

fn fold_front[T, U, F; Fork[F], Drop[F], Fn[F, (U, T), U]](...: Array[T], initial: U, f: F) -> U;

Fold over the array, starting from the front.

let array = Array([1, 2, 3]);
let str = array.fold_front("initial", fn* (str: String, value: N32) {
  "f({str}, {value})"
});
str // "f(f(f(initial, 1), 2), 3)"

fold_back root/data/Array.vi:134

fn fold_back[T, U, F; Fork[F], Drop[F], Fn[F, (U, T), U]](...: Array[T], initial: U, f: F) -> U;

Fold over the array, starting from the back.

let array = Array([1, 2, 3]);
let str = array.back("initial", fn* (value: N32, str: String) {
  "f({value}, {str})"
});
str // "f(1, f(2, f(3, initial)))"

len root/data/Array.vi:154

fn len[T](self: &Array[T]) -> N32;

The length of the array. O(1)

let array = [1, 2, 3] as Array;
array.len() // 3

at root/data/Array.vi:165

fn at[T](...: &Array[T], i: N32) -> Option[&T];

Access the ith element of the array. O(log n)

let array = ["a", "b", "C"] as Array;
array.at(1) // Some(&"b")
array.at(2).assume().* = "c";
array // Array(["a", "b", "c"])

get root/data/Array.vi:185

fn get[T; Fork[T]](self: &Array[T], i: N32) -> Option[T];

Get the ith element of the array. O(log n)

let array = ["a", "b", "c"] as Array;
array.get(0) // Some("a")
array.get(1) // Some("b")
array.get(3) // None

push_back root/data/Array.vi:195

fn push_back[T](...: &Array[T], value: T);

Append a value to the end of the array. O(log n)

let array = [1, 2, 3] as Array;
array.push_back(4);
array // Array([1, 2, 3, 4])

push_front root/data/Array.vi:217

fn push_front[T](...: &Array[T], value: T);

Append a value to the beginning of the array. O(log n)

let array = [1, 2, 3] as Array;
array.push_front(0);
array // Array([0, 1, 2, 3])

pop_back root/data/Array.vi:242

fn pop_back[T](...: &Array[T]) -> Option[T];

Remove the last value from the array. O(log n)

let array = [1, 2, 3] as Array;
array.pop_back() // Some(3)
array // Array([1, 2])

pop_front root/data/Array.vi:280

fn pop_front[T](...: &Array[T]) -> Option[T];

Remove the first value from the array. O(log n)

let array = [1, 2, 3] as Array;
array.pop_front() // Some(1)
array // Array([2, 3])

map_unordered root/data/Array.vi:317

fn map_unordered[T, U, F; Fork[F], Drop[F], Fn[F, (T,), U]](...: Array[T], f: F) -> Array[U];

Map over the array, applying the function to each element.

While the elements stay in the given order, the function is not necessarily applied to the elements in that order.

let array = [1, 2, 3] as Array;
array.map_unordered(fn* (val: N32) { val * 2 }) // Array([2, 4, 6])

reverse root/data/Array.vi:332

fn reverse[T](...: &Array[T]);

Reverse the elements of the array. O(n)

let array = [1, 2, 3] as Array;
array.reverse();
array // Array([3, 2, 1])

reversed root/data/Array.vi:341

fn reversed[T](self: Array[T]) -> Array[T];

Returns an array with the elements reversed. O(n)

let array = [1, 2, 3] as Array;
array.reversed() // Array([3, 2, 1])

fork root/data/Array.vi:347

impl fork[T; Fork[T]]: Fork[Array[T]];

drop root/data/Array.vi:358

impl drop[T; Drop[T]]: Drop[Array[T]];

show root/data/Array.vi:368

impl show[T; Show[T]]: Show[Array[T]];