Trait tract_core::internal::tract_ndarray::IntoNdProducer

pub trait IntoNdProducer {
    type Item;
    type Dim: Dimension;
    type Output: NdProducer
    where
        <Self::Output as NdProducer>::Dim == Self::Dim,
        <Self::Output as NdProducer>::Item == Self::Item;

    fn into_producer(self) -> Self::Output;
}

Argument conversion into a producer.

Slices and vectors can be used (equivalent to 1-dimensional array views).

This trait is like IntoIterator for NdProducers instead of iterators.

Required Associated Types

type Item

The element produced per iteration.

type Dim: Dimension

Dimension type of the producer

type Output: NdProducer
where
    <Self::Output as NdProducer>::Dim == Self::Dim,
    <Self::Output as NdProducer>::Item == Self::Item

Required Methods

fn into_producer(self) -> Self::Output

Convert the value into an NdProducer.

Implementations on Foreign Types

impl<'a, A> IntoNdProducer for &'a mut [A] where
    A: 'a, 

A mutable slice is a mutable one-dimensional producer

type Item = <<&'a mut [A] as IntoNdProducer>::Output as NdProducer>::Item

type Dim = Dim<[usize; 1]>

type Output = ArrayBase<ViewRepr<&'a mut A>, Dim<[usize; 1]>>

fn into_producer(self) -> <&'a mut [A] as IntoNdProducer>::Output

impl<'a, A> IntoNdProducer for &'a [A] where
    A: 'a, 

A slice is a one-dimensional producer

type Item = <<&'a [A] as IntoNdProducer>::Output as NdProducer>::Item

type Dim = Dim<[usize; 1]>

type Output = ArrayBase<ViewRepr<&'a A>, Dim<[usize; 1]>>

fn into_producer(self) -> <&'a [A] as IntoNdProducer>::Output

Implementors

impl<'a, A> IntoNdProducer for &'a Vec<A, Global> where
    A: 'a, 

A Vec is a one-dimensional producer

type Item = <<&'a Vec<A, Global> as IntoNdProducer>::Output as NdProducer>::Item

type Dim = Dim<[usize; 1]>

type Output = ArrayBase<ViewRepr<&'a A>, Dim<[usize; 1]>>

impl<'a, A> IntoNdProducer for &'a mut Vec<A, Global> where
    A: 'a, 

A mutable Vec is a mutable one-dimensional producer

type Item = <<&'a mut Vec<A, Global> as IntoNdProducer>::Output as NdProducer>::Item

type Dim = Dim<[usize; 1]>

type Output = ArrayBase<ViewRepr<&'a mut A>, Dim<[usize; 1]>>

impl<'a, A, S, D> IntoNdProducer for &'a ArrayBase<S, D> where
    A: 'a,
    D: Dimension,
    S: Data<Elem = A>, 

An array reference is an n-dimensional producer of element references (like ArrayView).

type Item = &'a A

type Dim = D

type Output = ArrayBase<ViewRepr<&'a A>, D>

impl<'a, A, S, D> IntoNdProducer for &'a mut ArrayBase<S, D> where
    A: 'a,
    D: Dimension,
    S: DataMut<Elem = A>, 

A mutable array reference is an n-dimensional producer of mutable element references (like ArrayViewMut).

type Item = &'a mut A

type Dim = D

type Output = ArrayBase<ViewRepr<&'a mut A>, D>

impl<P> IntoNdProducer for P where
    P: NdProducer, 

type Item = <P as NdProducer>::Item

type Dim = <P as NdProducer>::Dim

type Output = P