Module `std::vector`

A variable-sized container that can hold any type. Indexing is 0-based, and vectors are growable. This module has many native functions.

Constants
Function empty
Function length
Function borrow
Function push_back
Function borrow_mut
Function pop_back
Function destroy_empty
Function swap
Function singleton
Function reverse
Function append
Function is_empty
Function contains
Function index_of
Function remove
Function insert
Function swap_remove
Function skip
Function take
Macro function tabulate
Macro function destroy
Macro function do
Macro function do_ref
Macro function do_mut
Macro function map
Macro function map_ref
Macro function filter
Macro function partition
Macro function find_index
Macro function find_indices
Macro function count
Macro function fold
Function flatten
Macro function any
Macro function all
Macro function zip_do
Macro function zip_do_reverse
Macro function zip_do_ref
Macro function zip_do_mut
Macro function zip_map
Macro function zip_map_ref
Macro function insertion_sort_by
Macro function merge_sort_by
Macro function is_sorted_by
Macro function take_while
Macro function skip_while

Constants

The index into the vector is out of bounds

<pre><code>const <a href="../std/vector.md#std_vector_EINDEX_OUT_OF_BOUNDS">EINDEX_OUT_OF_BOUNDS</a>: <a href="../std/u64.md#std_u64">u64</a> = 131072; </code></pre>

Function `empty`

Create an empty vector.

<pre><code>public fun <a href="../std/vector.md#std_vector_empty">empty</a><Element>(): <a href="../std/vector.md#std_vector">vector</a><Element> </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_empty">empty</a><Element>(): <a href="../std/vector.md#std_vector">vector</a><Element>; </code></pre> </details>

Function `length`

Return the length of the vector.

<pre><code>public fun <a href="../std/vector.md#std_vector_length">length</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>): <a href="../std/u64.md#std_u64">u64</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_length">length</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>): <a href="../std/u64.md#std_u64">u64</a>; </code></pre> </details>

Function `borrow`

Acquire an immutable reference to the <code>i</code>th element of the vector <code>v</code>. Aborts if <code>i</code> is out of bounds.

<pre><code>public fun <a href="../std/vector.md#std_vector_borrow">borrow</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): &Element </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_borrow">borrow</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): &Element; </code></pre> </details>

Function `push_back`

Add element <code>e</code> to the end of the vector <code>v</code>.

<pre><code>public fun <a href="../std/vector.md#std_vector_push_back">push_back</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, e: Element) </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_push_back">push_back</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, e: Element); </code></pre> </details>

Function `borrow_mut`

Return a mutable reference to the <code>i</code>th element in the vector <code>v</code>. Aborts if <code>i</code> is out of bounds.

<pre><code>public fun <a href="../std/vector.md#std_vector_borrow_mut">borrow_mut</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): &mut Element </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_borrow_mut">borrow_mut</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): &mut Element; </code></pre> </details>

Function `pop_back`

Pop an element from the end of vector <code>v</code>. Aborts if <code>v</code> is empty.

<pre><code>public fun <a href="../std/vector.md#std_vector_pop_back">pop_back</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>): Element </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_pop_back">pop_back</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>): Element; </code></pre> </details>

Function `destroy_empty`

Destroy the vector <code>v</code>. Aborts if <code>v</code> is not empty.

<pre><code>public fun <a href="../std/vector.md#std_vector_destroy_empty">destroy_empty</a><Element>(v: <a href="../std/vector.md#std_vector">vector</a><Element>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_destroy_empty">destroy_empty</a><Element>(v: <a href="../std/vector.md#std_vector">vector</a><Element>); </code></pre> </details>

Function `swap`

Swaps the elements at the <code>i</code>th and <code>j</code>th indices in the vector <code>v</code>. Aborts if <code>i</code> or <code>j</code> is out of bounds.

<pre><code>public fun <a href="../std/vector.md#std_vector_swap">swap</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>, j: <a href="../std/u64.md#std_u64">u64</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public native fun <a href="../std/vector.md#std_vector_swap">swap</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>, j: <a href="../std/u64.md#std_u64">u64</a>); </code></pre> </details>

Function `singleton`

Return an vector of size one containing element <code>e</code>.

<pre><code>public fun <a href="../std/vector.md#std_vector_singleton">singleton</a><Element>(e: Element): <a href="../std/vector.md#std_vector">vector</a><Element> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_singleton">singleton</a><Element>(e: Element): <a href="../std/vector.md#std_vector">vector</a><Element> { let mut v = <a href="../std/vector.md#std_vector_empty">empty</a>(); v.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e); v } </code></pre> </details>

Function `reverse`

Reverses the order of the elements in the vector <code>v</code> in place.

<pre><code>public fun <a href="../std/vector.md#std_vector_reverse">reverse</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_reverse">reverse</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>) { let len = v.<a href="../std/vector.md#std_vector_length">length</a>(); if (len == 0) return; let mut front_index = 0; let mut back_index = len - 1; while (front_index < back_index) { v.<a href="../std/vector.md#std_vector_swap">swap</a>(front_index, back_index); front_index = front_index + 1; back_index = back_index - 1; } } </code></pre> </details>

Function `append`

Pushes all of the elements of the <code>other</code> vector into the <code>lhs</code> vector.

<pre><code>public fun <a href="../std/vector.md#std_vector_append">append</a><Element>(lhs: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, other: <a href="../std/vector.md#std_vector">vector</a><Element>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_append">append</a><Element>(lhs: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, other: <a href="../std/vector.md#std_vector">vector</a><Element>) { other.<a href="../std/vector.md#std_vector_do">do</a>!(|e| lhs.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e)); } </code></pre> </details>

Function `is_empty`

Return <code>true</code> if the vector <code>v</code> has no elements and <code>false</code> otherwise.

<pre><code>public fun <a href="../std/vector.md#std_vector_is_empty">is_empty</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>): <a href="../std/bool.md#std_bool">bool</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_is_empty">is_empty</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>): <a href="../std/bool.md#std_bool">bool</a> { v.<a href="../std/vector.md#std_vector_length">length</a>() == 0 } </code></pre> </details>

Function `contains`

Return true if <code>e</code> is in the vector <code>v</code>. Otherwise, returns false.

<pre><code>public fun <a href="../std/vector.md#std_vector_contains">contains</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>, e: &Element): <a href="../std/bool.md#std_bool">bool</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_contains">contains</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>, e: &Element): <a href="../std/bool.md#std_bool">bool</a> { let mut i = 0; let len = v.<a href="../std/vector.md#std_vector_length">length</a>(); while (i < len) { if (&v[i] == e) return true; i = i + 1; }; false } </code></pre> </details>

Function `index_of`

Return <code>(true, i)</code> if <code>e</code> is in the vector <code>v</code> at index <code>i</code>. Otherwise, returns <code>(false, 0)</code>.

<pre><code>public fun <a href="../std/vector.md#std_vector_index_of">index_of</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>, e: &Element): (<a href="../std/bool.md#std_bool">bool</a>, <a href="../std/u64.md#std_u64">u64</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_index_of">index_of</a><Element>(v: &<a href="../std/vector.md#std_vector">vector</a><Element>, e: &Element): (<a href="../std/bool.md#std_bool">bool</a>, <a href="../std/u64.md#std_u64">u64</a>) { let mut i = 0; let len = v.<a href="../std/vector.md#std_vector_length">length</a>(); while (i < len) { if (&v[i] == e) return (true, i); i = i + 1; }; (false, 0) } </code></pre> </details>

Function `remove`

Remove the <code>i</code>th element of the vector <code>v</code>, shifting all subsequent elements. This is O(n) and preserves ordering of elements in the vector. Aborts if <code>i</code> is out of bounds.

<pre><code>public fun <a href="../std/vector.md#std_vector_remove">remove</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): Element </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_remove">remove</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, mut i: <a href="../std/u64.md#std_u64">u64</a>): Element { let mut len = v.<a href="../std/vector.md#std_vector_length">length</a>(); // i out of bounds; abort if (i >= len) abort <a href="../std/vector.md#std_vector_EINDEX_OUT_OF_BOUNDS">EINDEX_OUT_OF_BOUNDS</a>; len = len - 1; while (i < len) { v.<a href="../std/vector.md#std_vector_swap">swap</a>(i, { i = i + 1; i }); }; v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>() } </code></pre> </details>

Function `insert`

Insert <code>e</code> at position <code>i</code> in the vector <code>v</code>. If <code>i</code> is in bounds, this shifts the old <code>v[i]</code> and all subsequent elements to the right. If <code>i == v.<a href="../std/vector.md#std_vector_length">length</a>()</code>, this adds <code>e</code> to the end of the vector. This is O(n) and preserves ordering of elements in the vector. Aborts if <code>i > v.<a href="../std/vector.md#std_vector_length">length</a>()</code>

<pre><code>public fun <a href="../std/vector.md#std_vector_insert">insert</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, e: Element, i: <a href="../std/u64.md#std_u64">u64</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_insert">insert</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, e: Element, mut i: <a href="../std/u64.md#std_u64">u64</a>) { let len = v.<a href="../std/vector.md#std_vector_length">length</a>(); // i too big abort if (i > len) abort <a href="../std/vector.md#std_vector_EINDEX_OUT_OF_BOUNDS">EINDEX_OUT_OF_BOUNDS</a>; v.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e); while (i < len) { v.<a href="../std/vector.md#std_vector_swap">swap</a>(i, len); i = i + 1 } } </code></pre> </details>

Function `swap_remove`

Swap the <code>i</code>th element of the vector <code>v</code> with the last element and then pop the vector. This is O(1), but does not preserve ordering of elements in the vector. Aborts if <code>i</code> is out of bounds.

<pre><code>public fun <a href="../std/vector.md#std_vector_swap_remove">swap_remove</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): Element </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_swap_remove">swap_remove</a><Element>(v: &mut <a href="../std/vector.md#std_vector">vector</a><Element>, i: <a href="../std/u64.md#std_u64">u64</a>): Element { assert!(v.<a href="../std/vector.md#std_vector_length">length</a>() != 0, <a href="../std/vector.md#std_vector_EINDEX_OUT_OF_BOUNDS">EINDEX_OUT_OF_BOUNDS</a>); let last_idx = v.<a href="../std/vector.md#std_vector_length">length</a>() - 1; v.<a href="../std/vector.md#std_vector_swap">swap</a>(i, last_idx); v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>() } </code></pre> </details>

Function `skip`

Return a new vector containing the elements of <code>v</code> except the first <code>n</code> elements. If <code>n > <a href="../std/vector.md#std_vector_length">length</a></code>, returns an empty vector.

<pre><code>public fun <a href="../std/vector.md#std_vector_skip">skip</a><T: drop>(v: <a href="../std/vector.md#std_vector">vector</a><T>, n: <a href="../std/u64.md#std_u64">u64</a>): <a href="../std/vector.md#std_vector">vector</a><T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_skip">skip</a><T: drop>(mut v: <a href="../std/vector.md#std_vector">vector</a><T>, n: <a href="../std/u64.md#std_u64">u64</a>): <a href="../std/vector.md#std_vector">vector</a><T> { let len = v.<a href="../std/vector.md#std_vector_length">length</a>(); if (n >= len) return <a href="../std/vector.md#std_vector">vector</a>[]; let mut r = <a href="../std/vector.md#std_vector_tabulate">tabulate</a>!(len - n, |_| v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>()); r.<a href="../std/vector.md#std_vector_reverse">reverse</a>(); r } </code></pre> </details>

Function `take`

Take the first <code>n</code> elements of the vector <code>v</code> and drop the rest. Aborts if <code>n</code> is greater than the length of <code>v</code>.

<pre><code>public fun <a href="../std/vector.md#std_vector_take">take</a><T: drop>(v: <a href="../std/vector.md#std_vector">vector</a><T>, n: <a href="../std/u64.md#std_u64">u64</a>): <a href="../std/vector.md#std_vector">vector</a><T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_take">take</a><T: drop>(mut v: <a href="../std/vector.md#std_vector">vector</a><T>, n: <a href="../std/u64.md#std_u64">u64</a>): <a href="../std/vector.md#std_vector">vector</a><T> { assert!(n <= v.<a href="../std/vector.md#std_vector_length">length</a>()); if (n == v.<a href="../std/vector.md#std_vector_length">length</a>()) return v; v.<a href="../std/vector.md#std_vector_reverse">reverse</a>(); <a href="../std/vector.md#std_vector_tabulate">tabulate</a>!(n, |_| v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>()) } </code></pre> </details>

Macro function `tabulate`

Create a vector of length <code>n</code> by calling the function <code>f</code> on each index.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_tabulate">tabulate</a><$T>($n: <a href="../std/u64.md#std_u64">u64</a>, $f: |<a href="../std/u64.md#std_u64">u64</a>| -> $T): <a href="../std/vector.md#std_vector">vector</a><$T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_tabulate">tabulate</a><$T>($n: <a href="../std/u64.md#std_u64">u64</a>, $f: |<a href="../std/u64.md#std_u64">u64</a>| -> $T): <a href="../std/vector.md#std_vector">vector</a><$T> { let mut v = <a href="../std/vector.md#std_vector">vector</a>[]; let n = $n; n.<a href="../std/vector.md#std_vector_do">do</a>!(|i| v.<a href="../std/vector.md#std_vector_push_back">push_back</a>($f(i))); v } </code></pre> </details>

Macro function `destroy`

Destroy the vector <code>v</code> by calling <code>f</code> on each element and then destroying the vector. Does not preserve the order of elements in the vector (starts from the end of the vector).

<pre><code>public macro fun <a href="../std/vector.md#std_vector_destroy">destroy</a><$T, $R: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |$T| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_destroy">destroy</a><$T, $R: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |$T| -> $R) { let mut v = $v; v.<a href="../std/vector.md#std_vector_length">length</a>().<a href="../std/vector.md#std_vector_do">do</a>!(|_| $f(v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>())); v.<a href="../std/vector.md#std_vector_destroy_empty">destroy_empty</a>(); } </code></pre> </details>

Macro function `do`

Destroy the vector <code>v</code> by calling <code>f</code> on each element and then destroying the vector. Preserves the order of elements in the vector.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_do">do</a><$T, $R: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |$T| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_do">do</a><$T, $R: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |$T| -> $R) { let mut v = $v; v.<a href="../std/vector.md#std_vector_reverse">reverse</a>(); v.<a href="../std/vector.md#std_vector_length">length</a>().<a href="../std/vector.md#std_vector_do">do</a>!(|_| $f(v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>())); v.<a href="../std/vector.md#std_vector_destroy_empty">destroy_empty</a>(); } </code></pre> </details>

Macro function `do_ref`

Perform an action <code>f</code> on each element of the vector <code>v</code>. The vector is not modified.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_do_ref">do_ref</a><$T, $R: drop>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_do_ref">do_ref</a><$T, $R: drop>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> $R) { let v = $v; v.<a href="../std/vector.md#std_vector_length">length</a>().<a href="../std/vector.md#std_vector_do">do</a>!(|i| $f(&v[i])) } </code></pre> </details>

Macro function `do_mut`

Perform an action <code>f</code> on each element of the vector <code>v</code>. The function <code>f</code> takes a mutable reference to the element.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_do_mut">do_mut</a><$T, $R: drop>($v: &mut <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&mut $T| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_do_mut">do_mut</a><$T, $R: drop>($v: &mut <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&mut $T| -> $R) { let v = $v; v.<a href="../std/vector.md#std_vector_length">length</a>().<a href="../std/vector.md#std_vector_do">do</a>!(|i| $f(&mut v[i])) } </code></pre> </details>

Macro function `map`

Map the vector <code>v</code> to a new vector by applying the function <code>f</code> to each element. Preserves the order of elements in the vector, first is called first.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_map">map</a><$T, $U>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |$T| -> $U): <a href="../std/vector.md#std_vector">vector</a><$U> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_map">map</a><$T, $U>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |$T| -> $U): <a href="../std/vector.md#std_vector">vector</a><$U> { let v = $v; let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_do">do</a>!(|e| r.<a href="../std/vector.md#std_vector_push_back">push_back</a>($f(e))); r } </code></pre> </details>

Macro function `map_ref`

Map the vector <code>v</code> to a new vector by applying the function <code>f</code> to each element. Preserves the order of elements in the vector, first is called first.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_map_ref">map_ref</a><$T, $U>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> $U): <a href="../std/vector.md#std_vector">vector</a><$U> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_map_ref">map_ref</a><$T, $U>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> $U): <a href="../std/vector.md#std_vector">vector</a><$U> { let v = $v; let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_do_ref">do_ref</a>!(|e| r.<a href="../std/vector.md#std_vector_push_back">push_back</a>($f(e))); r } </code></pre> </details>

Macro function `filter`

Filter the vector <code>v</code> by applying the function <code>f</code> to each element. Return a new vector containing only the elements for which <code>f</code> returns <code>true</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_filter">filter</a><$T: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><$T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_filter">filter</a><$T: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><$T> { let v = $v; let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_do">do</a>!(|e| if ($f(&e)) r.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e)); r } </code></pre> </details>

Macro function `partition`

Split the vector <code>v</code> into two vectors by applying the function <code>f</code> to each element. Return a tuple containing two vectors: the first containing the elements for which <code>f</code> returns <code>true</code>, and the second containing the elements for which <code>f</code> returns <code>false</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_partition">partition</a><$T>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): (<a href="../std/vector.md#std_vector">vector</a><$T>, <a href="../std/vector.md#std_vector">vector</a><$T>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_partition">partition</a><$T>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): (<a href="../std/vector.md#std_vector">vector</a><$T>, <a href="../std/vector.md#std_vector">vector</a><$T>) { let v = $v; let mut r1 = <a href="../std/vector.md#std_vector">vector</a>[]; let mut r2 = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_do">do</a>!(|e| if ($f(&e)) r1.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e) else r2.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e)); (r1, r2) } </code></pre> </details>

Macro function `find_index`

Finds the index of first element in the vector <code>v</code> that satisfies the predicate <code>f</code>. Returns <code>some(index)</code> if such an element is found, otherwise <code>none()</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_find_index">find_index</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/option.md#std_option_Option">std::option::Option</a><<a href="../std/u64.md#std_u64">u64</a>> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_find_index">find_index</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): Option<<a href="../std/u64.md#std_u64">u64</a>> { let v = $v; '<a href="../std/vector.md#std_vector_find_index">find_index</a>: { v.<a href="../std/vector.md#std_vector_length">length</a>().<a href="../std/vector.md#std_vector_do">do</a>!(|i| if ($f(&v[i])) return '<a href="../std/vector.md#std_vector_find_index">find_index</a> <a href="../std/option.md#std_option_some">option::some</a>(i)); <a href="../std/option.md#std_option_none">option::none</a>() } } </code></pre> </details>

Macro function `find_indices`

Finds all indices of elements in the vector <code>v</code> that satisfy the predicate <code>f</code>. Returns a vector of indices of all found elements.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_find_indices">find_indices</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><<a href="../std/u64.md#std_u64">u64</a>> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_find_indices">find_indices</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><<a href="../std/u64.md#std_u64">u64</a>> { let v = $v; let mut indices = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_length">length</a>().<a href="../std/vector.md#std_vector_do">do</a>!(|i| if ($f(&v[i])) indices.<a href="../std/vector.md#std_vector_push_back">push_back</a>(i)); indices } </code></pre> </details>

Macro function `count`

Count how many elements in the vector <code>v</code> satisfy the predicate <code>f</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_count">count</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/u64.md#std_u64">u64</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_count">count</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/u64.md#std_u64">u64</a> { let v = $v; let mut <a href="../std/vector.md#std_vector_count">count</a> = 0; v.<a href="../std/vector.md#std_vector_do_ref">do_ref</a>!(|e| if ($f(e)) <a href="../std/vector.md#std_vector_count">count</a> = <a href="../std/vector.md#std_vector_count">count</a> + 1); <a href="../std/vector.md#std_vector_count">count</a> } </code></pre> </details>

Macro function `fold`

Reduce the vector <code>v</code> to a single value by applying the function <code>f</code> to each element. Similar to <code>fold_left</code> in Rust and <code>reduce</code> in Python and JavaScript.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_fold">fold</a><$T, $Acc>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $init: $Acc, $f: |$Acc, $T| -> $Acc): $Acc </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_fold">fold</a><$T, $Acc>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $init: $Acc, $f: |$Acc, $T| -> $Acc): $Acc { let v = $v; let mut acc = $init; v.<a href="../std/vector.md#std_vector_do">do</a>!(|e| acc = $f(acc, e)); acc } </code></pre> </details>

Function `flatten`

Concatenate the vectors of <code>v</code> into a single vector, keeping the order of the elements.

<pre><code>public fun <a href="../std/vector.md#std_vector_flatten">flatten</a><T>(v: <a href="../std/vector.md#std_vector">vector</a><<a href="../std/vector.md#std_vector">vector</a><T>>): <a href="../std/vector.md#std_vector">vector</a><T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../std/vector.md#std_vector_flatten">flatten</a><T>(v: <a href="../std/vector.md#std_vector">vector</a><<a href="../std/vector.md#std_vector">vector</a><T>>): <a href="../std/vector.md#std_vector">vector</a><T> { let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_do">do</a>!(|u| r.<a href="../std/vector.md#std_vector_append">append</a>(u)); r } </code></pre> </details>

Macro function `any`

Whether any element in the vector <code>v</code> satisfies the predicate <code>f</code>. If the vector is empty, returns <code>false</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_any">any</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/bool.md#std_bool">bool</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_any">any</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/bool.md#std_bool">bool</a> { let v = $v; '<a href="../std/vector.md#std_vector_any">any</a>: { v.<a href="../std/vector.md#std_vector_do_ref">do_ref</a>!(|e| if ($f(e)) return '<a href="../std/vector.md#std_vector_any">any</a> true); false } } </code></pre> </details>

Macro function `all`

Whether all elements in the vector <code>v</code> satisfy the predicate <code>f</code>. If the vector is empty, returns <code>true</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_all">all</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/bool.md#std_bool">bool</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_all">all</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $f: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/bool.md#std_bool">bool</a> { let v = $v; '<a href="../std/vector.md#std_vector_all">all</a>: { v.<a href="../std/vector.md#std_vector_do_ref">do_ref</a>!(|e| if (!$f(e)) return '<a href="../std/vector.md#std_vector_all">all</a> false); true } } </code></pre> </details>

Macro function `zip_do`

Destroys two vectors <code>v1</code> and <code>v2</code> by calling <code>f</code> to each pair of elements. Aborts if the vectors are not of the same length. The order of elements in the vectors is preserved.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do">zip_do</a><$T1, $T2, $R: drop>($v1: <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |$T1, $T2| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do">zip_do</a><$T1, $T2, $R: drop>( $v1: <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |$T1, $T2| -> $R, ) { let v1 = $v1; let mut v2 = $v2; v2.<a href="../std/vector.md#std_vector_reverse">reverse</a>(); let len = v1.<a href="../std/vector.md#std_vector_length">length</a>(); assert!(len == v2.<a href="../std/vector.md#std_vector_length">length</a>()); v1.<a href="../std/vector.md#std_vector_do">do</a>!(|el1| $f(el1, v2.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>())); v2.<a href="../std/vector.md#std_vector_destroy_empty">destroy_empty</a>(); } </code></pre> </details>

Macro function `zip_do_reverse`

Destroys two vectors <code>v1</code> and <code>v2</code> by calling <code>f</code> to each pair of elements. Aborts if the vectors are not of the same length. Starts from the end of the vectors.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do_reverse">zip_do_reverse</a><$T1, $T2, $R: drop>($v1: <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |$T1, $T2| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do_reverse">zip_do_reverse</a><$T1, $T2, $R: drop>( $v1: <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |$T1, $T2| -> $R, ) { let v1 = $v1; let mut v2 = $v2; let len = v1.<a href="../std/vector.md#std_vector_length">length</a>(); assert!(len == v2.<a href="../std/vector.md#std_vector_length">length</a>()); v1.<a href="../std/vector.md#std_vector_destroy">destroy</a>!(|el1| $f(el1, v2.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>())); } </code></pre> </details>

Macro function `zip_do_ref`

Iterate through <code>v1</code> and <code>v2</code> and apply the function <code>f</code> to references of each pair of elements. The vectors are not modified. Aborts if the vectors are not of the same length. The order of elements in the vectors is preserved.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do_ref">zip_do_ref</a><$T1, $T2, $R: drop>($v1: &<a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: &<a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |&$T1, &$T2| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do_ref">zip_do_ref</a><$T1, $T2, $R: drop>( $v1: &<a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: &<a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |&$T1, &$T2| -> $R, ) { let v1 = $v1; let v2 = $v2; let len = v1.<a href="../std/vector.md#std_vector_length">length</a>(); assert!(len == v2.<a href="../std/vector.md#std_vector_length">length</a>()); len.<a href="../std/vector.md#std_vector_do">do</a>!(|i| $f(&v1[i], &v2[i])); } </code></pre> </details>

Macro function `zip_do_mut`

Iterate through <code>v1</code> and <code>v2</code> and apply the function <code>f</code> to mutable references of each pair of elements. The vectors may be modified. Aborts if the vectors are not of the same length. The order of elements in the vectors is preserved.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do_mut">zip_do_mut</a><$T1, $T2, $R: drop>($v1: &mut <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: &mut <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |&mut $T1, &mut $T2| -> $R) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_do_mut">zip_do_mut</a><$T1, $T2, $R: drop>( $v1: &mut <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: &mut <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |&mut $T1, &mut $T2| -> $R, ) { let v1 = $v1; let v2 = $v2; let len = v1.<a href="../std/vector.md#std_vector_length">length</a>(); assert!(len == v2.<a href="../std/vector.md#std_vector_length">length</a>()); len.<a href="../std/vector.md#std_vector_do">do</a>!(|i| $f(&mut v1[i], &mut v2[i])); } </code></pre> </details>

Macro function `zip_map`

Destroys two vectors <code>v1</code> and <code>v2</code> by applying the function <code>f</code> to each pair of elements. The returned values are collected into a new vector. Aborts if the vectors are not of the same length. The order of elements in the vectors is preserved.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_map">zip_map</a><$T1, $T2, $U>($v1: <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |$T1, $T2| -> $U): <a href="../std/vector.md#std_vector">vector</a><$U> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_map">zip_map</a><$T1, $T2, $U>( $v1: <a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: <a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |$T1, $T2| -> $U, ): <a href="../std/vector.md#std_vector">vector</a><$U> { let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; <a href="../std/vector.md#std_vector_zip_do">zip_do</a>!($v1, $v2, |el1, el2| r.<a href="../std/vector.md#std_vector_push_back">push_back</a>($f(el1, el2))); r } </code></pre> </details>

Macro function `zip_map_ref`

Iterate through <code>v1</code> and <code>v2</code> and apply the function <code>f</code> to references of each pair of elements. The returned values are collected into a new vector. Aborts if the vectors are not of the same length. The order of elements in the vectors is preserved.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_map_ref">zip_map_ref</a><$T1, $T2, $U>($v1: &<a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: &<a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |&$T1, &$T2| -> $U): <a href="../std/vector.md#std_vector">vector</a><$U> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_zip_map_ref">zip_map_ref</a><$T1, $T2, $U>( $v1: &<a href="../std/vector.md#std_vector">vector</a><$T1>, $v2: &<a href="../std/vector.md#std_vector">vector</a><$T2>, $f: |&$T1, &$T2| -> $U, ): <a href="../std/vector.md#std_vector">vector</a><$U> { let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; <a href="../std/vector.md#std_vector_zip_do_ref">zip_do_ref</a>!($v1, $v2, |el1, el2| r.<a href="../std/vector.md#std_vector_push_back">push_back</a>($f(el1, el2))); r } </code></pre> </details>

Macro function `insertion_sort_by`

Performs an in-place insertion sort on the vector <code>v</code> using the comparison function <code>le</code>. The sort is stable, meaning that equal elements will maintain their relative order.

Please, note that the comparison function <code>le</code> expects less or equal, not less.

Example:

let mut v = vector[2, 1, 3];
v.insertion_sort_by(|a, b| a <= b);
assert!(v == vector[1, 2, 3]);

Insertion sort is efficient for small vectors (~30 or less elements), and can be faster than merge sort for almost sorted vectors (e.g. when the vector is already sorted or nearly sorted).

<pre><code>public macro fun <a href="../std/vector.md#std_vector_insertion_sort_by">insertion_sort_by</a><$T>($v: &mut <a href="../std/vector.md#std_vector">vector</a><$T>, $le: |&$T, &$T| -> <a href="../std/bool.md#std_bool">bool</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_insertion_sort_by">insertion_sort_by</a><$T>($v: &mut <a href="../std/vector.md#std_vector">vector</a><$T>, $le: |&$T, &$T| -> <a href="../std/bool.md#std_bool">bool</a>) { let v = $v; let n = v.<a href="../std/vector.md#std_vector_length">length</a>(); if (n < 2) return; // <a href="../std/vector.md#std_vector_do">do</a> insertion sort let mut i = 1; while (i < n) { let mut j = i; while (j > 0 && !$le(&v[j - 1], &v[j])) { v.<a href="../std/vector.md#std_vector_swap">swap</a>(j, j - 1); j = j - 1; }; i = i + 1; } } </code></pre> </details>

Macro function `merge_sort_by`

Performs an in-place merge sort on the vector <code>v</code> using the comparison function <code>le</code>. Merge sort is efficient for large vectors, and is a stable sort.

Please, note that the comparison function <code>le</code> expects less or equal, not less.

Example:

let mut v = vector[2, 1, 3];
v.merge_sort_by(|a, b| a <= b);
assert!(v == vector[1, 2, 3]);

Merge sort performs better than insertion sort for large vectors (~30 elements or more).

<pre><code>public macro fun <a href="../std/vector.md#std_vector_merge_sort_by">merge_sort_by</a><$T>($v: &mut <a href="../std/vector.md#std_vector">vector</a><$T>, $le: |&$T, &$T| -> <a href="../std/bool.md#std_bool">bool</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_merge_sort_by">merge_sort_by</a><$T>($v: &mut <a href="../std/vector.md#std_vector">vector</a><$T>, $le: |&$T, &$T| -> <a href="../std/bool.md#std_bool">bool</a>) { let v = $v; let n = v.<a href="../std/vector.md#std_vector_length">length</a>(); if (n < 2) return; let mut flags = <a href="../std/vector.md#std_vector">vector</a>[false]; let mut starts = <a href="../std/vector.md#std_vector">vector</a>[0]; let mut ends = <a href="../std/vector.md#std_vector">vector</a>[n]; while (!flags.<a href="../std/vector.md#std_vector_is_empty">is_empty</a>()) { let (halves_sorted, start, end) = (flags.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>(), starts.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>(), ends.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>()); let mid = (start + end) / 2; if (halves_sorted) { let mut mid = mid; let mut l = start; let mut r = mid; while (l < mid && r < end) { if ($le(&v[l], &v[r])) { l = l + 1; } else { let mut i = r; while (i > l) { v.<a href="../std/vector.md#std_vector_swap">swap</a>(i, i - 1); i = i - 1; }; l = l + 1; mid = mid + 1; r = r + 1; } } } else { // set up the "merge" flags.<a href="../std/vector.md#std_vector_push_back">push_back</a>(true); starts.<a href="../std/vector.md#std_vector_push_back">push_back</a>(start); ends.<a href="../std/vector.md#std_vector_push_back">push_back</a>(end); // set up the recursive calls // v[start..mid] if (mid - start > 1) { flags.<a href="../std/vector.md#std_vector_push_back">push_back</a>(false); starts.<a href="../std/vector.md#std_vector_push_back">push_back</a>(start); ends.<a href="../std/vector.md#std_vector_push_back">push_back</a>(mid); }; // v[mid..end] if (end - mid > 1) { flags.<a href="../std/vector.md#std_vector_push_back">push_back</a>(false); starts.<a href="../std/vector.md#std_vector_push_back">push_back</a>(mid); ends.<a href="../std/vector.md#std_vector_push_back">push_back</a>(end); } } } } </code></pre> </details>

Macro function `is_sorted_by`

Check if the vector <code>v</code> is sorted in non-decreasing order according to the comparison function <code>le</code> (les). Returns <code>true</code> if the vector is sorted, <code>false</code> otherwise.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_is_sorted_by">is_sorted_by</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $le: |&$T, &$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/bool.md#std_bool">bool</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_is_sorted_by">is_sorted_by</a><$T>($v: &<a href="../std/vector.md#std_vector">vector</a><$T>, $le: |&$T, &$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/bool.md#std_bool">bool</a> { let v = $v; let n_minus_1 = v.<a href="../std/vector.md#std_vector_length">length</a>().max(1) - 1; '<a href="../std/vector.md#std_vector_is_sorted_by">is_sorted_by</a>: { n_minus_1.<a href="../std/vector.md#std_vector_do">do</a>!(|i| if (!$le(&v[i], &v[i + 1])) return '<a href="../std/vector.md#std_vector_is_sorted_by">is_sorted_by</a> false); true } } </code></pre> </details>

Macro function `take_while`

Return a new vector containing the elements of <code>v</code> except the first <code>n</code> elements that satisfy the predicate <code>p</code>. If all elements satisfy the predicate, returns an empty vector.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_take_while">take_while</a><$T: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $p: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><$T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_take_while">take_while</a><$T: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $p: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><$T> { let v = $v; '<a href="../std/vector.md#std_vector_take">take</a>: { let mut r = <a href="../std/vector.md#std_vector">vector</a>[]; v.<a href="../std/vector.md#std_vector_do">do</a>!(|e| if ($p(&e)) r.<a href="../std/vector.md#std_vector_push_back">push_back</a>(e) else return '<a href="../std/vector.md#std_vector_take">take</a> r); r } } </code></pre> </details>

Macro function `skip_while`

Take all elements of the vector <code>v</code> except the first <code>n</code> elements that satisfy the predicate <code>p</code> and drop the rest, where <code>n <= v.<a href="../std/vector.md#std_vector_length">length</a>()</code>.

<pre><code>public macro fun <a href="../std/vector.md#std_vector_skip_while">skip_while</a><$T: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $p: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><$T> </code></pre> <details> <summary>Implementation</summary> <pre><code>public macro fun <a href="../std/vector.md#std_vector_skip_while">skip_while</a><$T: drop>($v: <a href="../std/vector.md#std_vector">vector</a><$T>, $p: |&$T| -> <a href="../std/bool.md#std_bool">bool</a>): <a href="../std/vector.md#std_vector">vector</a><$T> { let mut v = $v; v.<a href="../std/vector.md#std_vector_reverse">reverse</a>(); let mut i = v.<a href="../std/vector.md#std_vector_length">length</a>(); while (i > 0) { i = i - 1; if ($p(&v[i])) v.<a href="../std/vector.md#std_vector_pop_back">pop_back</a>() else break; }; v.<a href="../std/vector.md#std_vector_reverse">reverse</a>(); v } </code></pre> </details>

Constants

Function empty

Function length

Function borrow

Function push_back

Function borrow_mut

Function pop_back

Function destroy_empty

Function swap

Function singleton

Function reverse

Function append

Function is_empty

Function contains

Function index_of

Function remove

Function insert

Function swap_remove

Function skip

Function take

Macro function tabulate

Macro function destroy

Macro function do

Macro function do_ref

Macro function do_mut

Macro function map

Macro function map_ref

Macro function filter

Macro function partition

Macro function find_index

Macro function find_indices

Macro function count

Macro function fold

Function flatten

Macro function any

Macro function all

Macro function zip_do

Macro function zip_do_reverse

Macro function zip_do_ref

Macro function zip_do_mut

Macro function zip_map

Macro function zip_map_ref

Macro function insertion_sort_by

Macro function merge_sort_by

Macro function is_sorted_by

Macro function take_while

Macro function skip_while