`#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:91`

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:110`

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:132`

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)))"

`reduce_unordered` `root/data/Array.vi:146`

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

`len` `root/data/Array.vi:160`

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:171`

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:191`

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:201`

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:223`

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:248`

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:286`

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:323`

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:338`

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:347`

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])

`zip_with` `root/data/Array.vi:360`

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

Zips the two arrays with a given function combining the corresponding elements.

Safety: Errors if the two arrays have different lengths.

let left = ["ab", "x"] as Array;
let right = ["cd", "yz"] as Array;
left.zip_with(right, Concat::concat) // Array(["abcd", "xyz"])

`unzip_with` `root/data/Array.vi:385`

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

let array = ["abcde", "qwerty"] as Array;
let (left, right) = array.unzip_with(fn* (s: String) { s.split_at(3) })
left // Array(["abc", "qwe"])
right // Array(["de", "rty"])

`eq` `root/data/Array.vi:398`

impl eq[T; Eq[T]]: Eq[Array[T]];

`fork` `root/data/Array.vi:409`

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

`drop` `root/data/Array.vi:420`

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

`show` `root/data/Array.vi:430`

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

Array root/data/Array.vi

`Array` `root/data/Array.vi`