Trait ArrayEnumerateMapOuter

pub trait ArrayEnumerateMapOuter<T, const N: usize>: ArrayEnumerate<T, N> + ArrayMapOuter<T, N> {
    // Required methods
    const fn enumerate_map_outer<Map>(
        &self,
        mapper: Map,
    ) -> [[Map::Output; N]; N]
       where Map: FnMut<(usize, usize, T, T)>,
             T: Copy;
    const fn enumerate_map_outer_ref<'a, Map>(
        &'a self,
        mapper: Map,
    ) -> [[Map::Output; N]; N]
       where Map: FnMut<(usize, usize, &'a T, &'a T)>;
    const fn enumerate_map_outer_pin_ref<'a, Map>(
        self: Pin<&'a Self>,
        mapper: Map,
    ) -> [[Map::Output; N]; N]
       where Map: FnMut<(usize, usize, Pin<&'a T>, Pin<&'a T>)>;
    const async fn enumerate_map_outer_async<Map>(
        &self,
        mapper: Map,
    ) -> [[Map::Output; N]; N]
       where Map: AsyncFn<(usize, usize, T, T)>,
             T: Copy;
    const async fn enumerate_map_outer_ref_async<'a, Map>(
        &'a self,
        mapper: Map,
    ) -> [[Map::Output; N]; N]
       where Map: AsyncFn<(usize, usize, &'a T, &'a T)>,
             T: 'a;
    const async fn enumerate_map_outer_pin_ref_async<'a, Map>(
        self: Pin<&'a Self>,
        mapper: Map,
    ) -> [[Map::Output; N]; N]
       where Map: AsyncFn<(usize, usize, Pin<&'a T>, Pin<&'a T>)>,
             T: 'a;
    const fn try_enumerate_map_outer<Map, U, E>(
        &self,
        mapper: Map,
    ) -> Result<[[U; N]; N], E>
       where Map: FnMut(usize, usize, T, T) -> Result<U, E>,
             T: Copy;
    const fn try_enumerate_map_outer_ref<'a, Map, U, E>(
        &'a self,
        mapper: Map,
    ) -> Result<[[U; N]; N], E>
       where Map: FnMut(usize, usize, &'a T, &'a T) -> Result<U, E>,
             T: 'a;
    const fn try_enumerate_map_outer_pin_ref<'a, Map, U, E>(
        self: Pin<&'a Self>,
        mapper: Map,
    ) -> Result<[[U; N]; N], E>
       where Map: FnMut(usize, usize, Pin<&'a T>, Pin<&'a T>) -> Result<U, E>,
             T: 'a;
    const async fn try_enumerate_map_outer_async<Map, U, E>(
        &self,
        mapper: Map,
    ) -> Result<[[U; N]; N], E>
       where Map: AsyncFn(usize, usize, T, T) -> Result<U, E>,
             T: Copy;
    const async fn try_enumerate_map_outer_ref_async<'a, Map, U, E>(
        &'a self,
        mapper: Map,
    ) -> Result<[[U; N]; N], E>
       where Map: AsyncFn(usize, usize, &'a T, &'a T) -> Result<U, E>,
             T: 'a;
    const async fn try_enumerate_map_outer_pin_ref_async<'a, Map, U, E>(
        self: Pin<&'a Self>,
        mapper: Map,
    ) -> Result<[[U; N]; N], E>
       where Map: AsyncFn(usize, usize, Pin<&'a T>, Pin<&'a T>) -> Result<U, E>,
             T: 'a;
}

Required Methods

const fn enumerate_map_outer<Map>(&self, mapper: Map) -> [[Map::Output; N]; N]

where Map: FnMut<(usize, usize, T, T)>, T: Copy,

const fn enumerate_map_outer_ref<'a, Map>( &'a self, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: FnMut<(usize, usize, &'a T, &'a T)>,

const fn enumerate_map_outer_pin_ref<'a, Map>( self: Pin<&'a Self>, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: FnMut<(usize, usize, Pin<&'a T>, Pin<&'a T>)>,

const async fn enumerate_map_outer_async<Map>( &self, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: AsyncFn<(usize, usize, T, T)>, T: Copy,

const async fn enumerate_map_outer_ref_async<'a, Map>( &'a self, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: AsyncFn<(usize, usize, &'a T, &'a T)>, T: 'a,

const async fn enumerate_map_outer_pin_ref_async<'a, Map>( self: Pin<&'a Self>, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: AsyncFn<(usize, usize, Pin<&'a T>, Pin<&'a T>)>, T: 'a,

const fn try_enumerate_map_outer<Map, U, E>( &self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: FnMut(usize, usize, T, T) -> Result<U, E>, T: Copy,

const fn try_enumerate_map_outer_ref<'a, Map, U, E>( &'a self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: FnMut(usize, usize, &'a T, &'a T) -> Result<U, E>, T: 'a,

const fn try_enumerate_map_outer_pin_ref<'a, Map, U, E>( self: Pin<&'a Self>, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: FnMut(usize, usize, Pin<&'a T>, Pin<&'a T>) -> Result<U, E>, T: 'a,

const async fn try_enumerate_map_outer_async<Map, U, E>( &self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: AsyncFn(usize, usize, T, T) -> Result<U, E>, T: Copy,

const async fn try_enumerate_map_outer_ref_async<'a, Map, U, E>( &'a self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: AsyncFn(usize, usize, &'a T, &'a T) -> Result<U, E>, T: 'a,

const async fn try_enumerate_map_outer_pin_ref_async<'a, Map, U, E>( self: Pin<&'a Self>, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: AsyncFn(usize, usize, Pin<&'a T>, Pin<&'a T>) -> Result<U, E>, T: 'a,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T, const N: usize> ArrayEnumerateMapOuter<T, N> for [T; N]

fn enumerate_map_outer<Map>(&self, mapper: Map) -> [[Map::Output; N]; N]

where Map: FnMut<(usize, usize, T, T)> + Destruct, T: Copy,

fn enumerate_map_outer_ref<'a, Map>( &'a self, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: FnMut<(usize, usize, &'a T, &'a T)>,

fn enumerate_map_outer_pin_ref<'a, Map>( self: Pin<&'a Self>, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: FnMut<(usize, usize, Pin<&'a T>, Pin<&'a T>)>,

async fn enumerate_map_outer_async<Map>( &self, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: AsyncFn<(usize, usize, T, T)>, T: Copy,

async fn enumerate_map_outer_ref_async<'a, Map>( &'a self, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: AsyncFn<(usize, usize, &'a T, &'a T)>, T: 'a,

async fn enumerate_map_outer_pin_ref_async<'a, Map>( self: Pin<&'a Self>, mapper: Map, ) -> [[Map::Output; N]; N]

where Map: AsyncFn<(usize, usize, Pin<&'a T>, Pin<&'a T>)>, T: 'a,

fn try_enumerate_map_outer<Map, U, E>( &self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: FnMut(usize, usize, T, T) -> Result<U, E>, T: Copy,

fn try_enumerate_map_outer_ref<'a, Map, U, E>( &'a self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: FnMut(usize, usize, &'a T, &'a T) -> Result<U, E>, T: 'a,

fn try_enumerate_map_outer_pin_ref<'a, Map, U, E>( self: Pin<&'a Self>, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: FnMut(usize, usize, Pin<&'a T>, Pin<&'a T>) -> Result<U, E>, T: 'a,

async fn try_enumerate_map_outer_async<Map, U, E>( &self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: AsyncFn(usize, usize, T, T) -> Result<U, E>, T: Copy,

async fn try_enumerate_map_outer_ref_async<'a, Map, U, E>( &'a self, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: AsyncFn(usize, usize, &'a T, &'a T) -> Result<U, E>, T: 'a,

async fn try_enumerate_map_outer_pin_ref_async<'a, Map, U, E>( self: Pin<&'a Self>, mapper: Map, ) -> Result<[[U; N]; N], E>

where Map: AsyncFn(usize, usize, Pin<&'a T>, Pin<&'a T>) -> Result<U, E>, T: 'a,

Implementors