Enum vectoreyes::array_utils::ArrayUnrolledOps

pub enum ArrayUnrolledOps {}

A type which can be used to require that unrolled operations exist for a given array size.

Example

use vectoreyes::array_utils::*;
pub fn make_fun_array<const N: usize>() -> [usize; N]
    where ArrayUnrolledOps: UnrollableArraySize<N>
{
    <[usize; N]>::array_generate(|i| i + 10)
}
assert_eq!(make_fun_array::<4>(), [10, 11, 12, 13]);

Trait Implementations

impl UnrollableArraySize<0> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 0]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 0], f: F) -> [U; 0]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 0],
    f: F
) -> Result<[U; 0], E>

fn array_enumerate<T>(arr: [T; 0]) -> [(usize, T); 0]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 0], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 0], arr2: [T2; 0]) -> [(T1, T2); 0]

impl UnrollableArraySize<1> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 1]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 1], f: F) -> [U; 1]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 1],
    f: F
) -> Result<[U; 1], E>

fn array_enumerate<T>(arr: [T; 1]) -> [(usize, T); 1]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 1], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 1], arr2: [T2; 1]) -> [(T1, T2); 1]

impl UnrollableArraySize<10> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 10]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 10], f: F) -> [U; 10]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 10],
    f: F
) -> Result<[U; 10], E>

fn array_enumerate<T>(arr: [T; 10]) -> [(usize, T); 10]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 10], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 10], arr2: [T2; 10]) -> [(T1, T2); 10]

impl UnrollableArraySize<11> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 11]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 11], f: F) -> [U; 11]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 11],
    f: F
) -> Result<[U; 11], E>

fn array_enumerate<T>(arr: [T; 11]) -> [(usize, T); 11]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 11], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 11], arr2: [T2; 11]) -> [(T1, T2); 11]

impl UnrollableArraySize<12> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 12]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 12], f: F) -> [U; 12]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 12],
    f: F
) -> Result<[U; 12], E>

fn array_enumerate<T>(arr: [T; 12]) -> [(usize, T); 12]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 12], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 12], arr2: [T2; 12]) -> [(T1, T2); 12]

impl UnrollableArraySize<13> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 13]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 13], f: F) -> [U; 13]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 13],
    f: F
) -> Result<[U; 13], E>

fn array_enumerate<T>(arr: [T; 13]) -> [(usize, T); 13]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 13], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 13], arr2: [T2; 13]) -> [(T1, T2); 13]

impl UnrollableArraySize<14> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 14]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 14], f: F) -> [U; 14]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 14],
    f: F
) -> Result<[U; 14], E>

fn array_enumerate<T>(arr: [T; 14]) -> [(usize, T); 14]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 14], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 14], arr2: [T2; 14]) -> [(T1, T2); 14]

impl UnrollableArraySize<15> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 15]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 15], f: F) -> [U; 15]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 15],
    f: F
) -> Result<[U; 15], E>

fn array_enumerate<T>(arr: [T; 15]) -> [(usize, T); 15]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 15], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 15], arr2: [T2; 15]) -> [(T1, T2); 15]

impl UnrollableArraySize<16> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 16]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 16], f: F) -> [U; 16]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 16],
    f: F
) -> Result<[U; 16], E>

fn array_enumerate<T>(arr: [T; 16]) -> [(usize, T); 16]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 16], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 16], arr2: [T2; 16]) -> [(T1, T2); 16]

impl UnrollableArraySize<17> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 17]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 17], f: F) -> [U; 17]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 17],
    f: F
) -> Result<[U; 17], E>

fn array_enumerate<T>(arr: [T; 17]) -> [(usize, T); 17]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 17], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 17], arr2: [T2; 17]) -> [(T1, T2); 17]

impl UnrollableArraySize<18> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 18]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 18], f: F) -> [U; 18]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 18],
    f: F
) -> Result<[U; 18], E>

fn array_enumerate<T>(arr: [T; 18]) -> [(usize, T); 18]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 18], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 18], arr2: [T2; 18]) -> [(T1, T2); 18]

impl UnrollableArraySize<19> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 19]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 19], f: F) -> [U; 19]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 19],
    f: F
) -> Result<[U; 19], E>

fn array_enumerate<T>(arr: [T; 19]) -> [(usize, T); 19]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 19], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 19], arr2: [T2; 19]) -> [(T1, T2); 19]

impl UnrollableArraySize<2> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 2]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 2], f: F) -> [U; 2]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 2],
    f: F
) -> Result<[U; 2], E>

fn array_enumerate<T>(arr: [T; 2]) -> [(usize, T); 2]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 2], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 2], arr2: [T2; 2]) -> [(T1, T2); 2]

impl UnrollableArraySize<20> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 20]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 20], f: F) -> [U; 20]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 20],
    f: F
) -> Result<[U; 20], E>

fn array_enumerate<T>(arr: [T; 20]) -> [(usize, T); 20]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 20], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 20], arr2: [T2; 20]) -> [(T1, T2); 20]

impl UnrollableArraySize<21> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 21]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 21], f: F) -> [U; 21]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 21],
    f: F
) -> Result<[U; 21], E>

fn array_enumerate<T>(arr: [T; 21]) -> [(usize, T); 21]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 21], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 21], arr2: [T2; 21]) -> [(T1, T2); 21]

impl UnrollableArraySize<22> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 22]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 22], f: F) -> [U; 22]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 22],
    f: F
) -> Result<[U; 22], E>

fn array_enumerate<T>(arr: [T; 22]) -> [(usize, T); 22]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 22], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 22], arr2: [T2; 22]) -> [(T1, T2); 22]

impl UnrollableArraySize<23> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 23]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 23], f: F) -> [U; 23]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 23],
    f: F
) -> Result<[U; 23], E>

fn array_enumerate<T>(arr: [T; 23]) -> [(usize, T); 23]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 23], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 23], arr2: [T2; 23]) -> [(T1, T2); 23]

impl UnrollableArraySize<24> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 24]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 24], f: F) -> [U; 24]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 24],
    f: F
) -> Result<[U; 24], E>

fn array_enumerate<T>(arr: [T; 24]) -> [(usize, T); 24]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 24], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 24], arr2: [T2; 24]) -> [(T1, T2); 24]

impl UnrollableArraySize<25> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 25]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 25], f: F) -> [U; 25]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 25],
    f: F
) -> Result<[U; 25], E>

fn array_enumerate<T>(arr: [T; 25]) -> [(usize, T); 25]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 25], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 25], arr2: [T2; 25]) -> [(T1, T2); 25]

impl UnrollableArraySize<26> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 26]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 26], f: F) -> [U; 26]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 26],
    f: F
) -> Result<[U; 26], E>

fn array_enumerate<T>(arr: [T; 26]) -> [(usize, T); 26]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 26], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 26], arr2: [T2; 26]) -> [(T1, T2); 26]

impl UnrollableArraySize<27> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 27]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 27], f: F) -> [U; 27]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 27],
    f: F
) -> Result<[U; 27], E>

fn array_enumerate<T>(arr: [T; 27]) -> [(usize, T); 27]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 27], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 27], arr2: [T2; 27]) -> [(T1, T2); 27]

impl UnrollableArraySize<28> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 28]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 28], f: F) -> [U; 28]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 28],
    f: F
) -> Result<[U; 28], E>

fn array_enumerate<T>(arr: [T; 28]) -> [(usize, T); 28]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 28], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 28], arr2: [T2; 28]) -> [(T1, T2); 28]

impl UnrollableArraySize<29> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 29]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 29], f: F) -> [U; 29]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 29],
    f: F
) -> Result<[U; 29], E>

fn array_enumerate<T>(arr: [T; 29]) -> [(usize, T); 29]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 29], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 29], arr2: [T2; 29]) -> [(T1, T2); 29]

impl UnrollableArraySize<3> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 3]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 3], f: F) -> [U; 3]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 3],
    f: F
) -> Result<[U; 3], E>

fn array_enumerate<T>(arr: [T; 3]) -> [(usize, T); 3]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 3], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 3], arr2: [T2; 3]) -> [(T1, T2); 3]

impl UnrollableArraySize<30> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 30]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 30], f: F) -> [U; 30]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 30],
    f: F
) -> Result<[U; 30], E>

fn array_enumerate<T>(arr: [T; 30]) -> [(usize, T); 30]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 30], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 30], arr2: [T2; 30]) -> [(T1, T2); 30]

impl UnrollableArraySize<31> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 31]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 31], f: F) -> [U; 31]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 31],
    f: F
) -> Result<[U; 31], E>

fn array_enumerate<T>(arr: [T; 31]) -> [(usize, T); 31]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 31], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 31], arr2: [T2; 31]) -> [(T1, T2); 31]

impl UnrollableArraySize<32> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 32]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 32], f: F) -> [U; 32]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 32],
    f: F
) -> Result<[U; 32], E>

fn array_enumerate<T>(arr: [T; 32]) -> [(usize, T); 32]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 32], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 32], arr2: [T2; 32]) -> [(T1, T2); 32]

impl UnrollableArraySize<4> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 4]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 4], f: F) -> [U; 4]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 4],
    f: F
) -> Result<[U; 4], E>

fn array_enumerate<T>(arr: [T; 4]) -> [(usize, T); 4]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 4], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 4], arr2: [T2; 4]) -> [(T1, T2); 4]

impl UnrollableArraySize<5> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 5]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 5], f: F) -> [U; 5]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 5],
    f: F
) -> Result<[U; 5], E>

fn array_enumerate<T>(arr: [T; 5]) -> [(usize, T); 5]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 5], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 5], arr2: [T2; 5]) -> [(T1, T2); 5]

impl UnrollableArraySize<6> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 6]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 6], f: F) -> [U; 6]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 6],
    f: F
) -> Result<[U; 6], E>

fn array_enumerate<T>(arr: [T; 6]) -> [(usize, T); 6]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 6], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 6], arr2: [T2; 6]) -> [(T1, T2); 6]

impl UnrollableArraySize<7> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 7]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 7], f: F) -> [U; 7]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 7],
    f: F
) -> Result<[U; 7], E>

fn array_enumerate<T>(arr: [T; 7]) -> [(usize, T); 7]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 7], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 7], arr2: [T2; 7]) -> [(T1, T2); 7]

impl UnrollableArraySize<8> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 8]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 8], f: F) -> [U; 8]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 8],
    f: F
) -> Result<[U; 8], E>

fn array_enumerate<T>(arr: [T; 8]) -> [(usize, T); 8]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 8], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 8], arr2: [T2; 8]) -> [(T1, T2); 8]

impl UnrollableArraySize<9> for ArrayUnrolledOps

fn array_generate<T, F: FnMut(usize) -> T>(f: F) -> [T; 9]

fn array_map<T, U, F: FnMut(T) -> U>(arr: [T; 9], f: F) -> [U; 9]

fn array_map_result<T, U, E, F: FnMut(T) -> Result<U, E>>(
    arr: [T; 9],
    f: F
) -> Result<[U; 9], E>

fn array_enumerate<T>(arr: [T; 9]) -> [(usize, T); 9]

fn array_fold<T, U, F: FnMut(U, T) -> U>(arr: [T; 9], init: U, f: F) -> U

fn array_zip<T1, T2>(arr1: [T1; 9], arr2: [T2; 9]) -> [(T1, T2); 9]