Trait View 

pub trait View<'a> {
    type Type: Viewed;

    // Required method
    fn view(&'a self) -> Self::Type;
}

A trait defining a collection that can be accessed via an immutable (shared) view. This type of view can be cloned and copied.

Required Associated Types

type Type: Viewed

Required Methods

fn view(&'a self) -> Self::Type

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, I: IntBound> View<'a> for Range<I>

type Type = Range<I>

fn view(&'a self) -> Self::Type

impl<'a, I: IntBound> View<'a> for RangeInclusive<I>

type Type = RangeInclusive<I>

fn view(&'a self) -> Self::Type

impl<'a, I: IntBound> View<'a> for RangeTo<I>

type Type = RangeTo<I>

fn view(&'a self) -> Self::Type

impl<'a, I: IntBound> View<'a> for RangeToInclusive<I>

type Type = RangeToInclusive<I>

fn view(&'a self) -> Self::Type

impl<'a, S: ?Sized + 'a + View<'a>> View<'a> for &S

Blanket implementation of View for all immutable borrows.

type Type = <S as View<'a>>::Type

fn view(&'a self) -> Self::Type

impl<'a, S: ?Sized + 'a + View<'a>> View<'a> for &mut S

Blanket implementation of View for all mutable borrows.

type Type = <S as View<'a>>::Type

fn view(&'a self) -> Self::Type

impl<'a, S: View<'a>, T: View<'a>> View<'a> for (S, T)

type Type = (<S as View<'a>>::Type, <T as View<'a>>::Type)

fn view(&'a self) -> Self::Type

impl<'a, S: View<'a>> View<'a> for Box<S>

type Type = <S as View<'a>>::Type

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for Vec<T>

type Type = &'a [T]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 1]

type Type = &'a [T; 1]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 2]

type Type = &'a [T; 2]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 3]

type Type = &'a [T; 3]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 4]

type Type = &'a [T; 4]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 5]

type Type = &'a [T; 5]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 6]

type Type = &'a [T; 6]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 7]

type Type = &'a [T; 7]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 8]

type Type = &'a [T; 8]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 9]

type Type = &'a [T; 9]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 10]

type Type = &'a [T; 10]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 11]

type Type = &'a [T; 11]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 12]

type Type = &'a [T; 12]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 13]

type Type = &'a [T; 13]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 14]

type Type = &'a [T; 14]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 15]

type Type = &'a [T; 15]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T; 16]

type Type = &'a [T; 16]

fn view(&'a self) -> Self::Type

impl<'a, T: 'a> View<'a> for [T]

type Type = &'a [T]

fn view(&'a self) -> Self::Type

Implementors

impl<'a, O: AsRef<[usize]>> View<'a> for ClumpedOffsets<O>

type Type = ClumpedOffsets<&'a [usize]>

impl<'a, O: AsRef<[usize]>> View<'a> for Offsets<O>

type Type = Offsets<&'a [usize]>

impl<'a, S, I> View<'a> for Select<S, I>

where S: View<'a>, I: AsIndexSlice,

type Type = Select<<S as View<'a>>::Type, &'a [usize]>

impl<'a, S, I> View<'a> for Subset<S, I>

where S: View<'a>, I: AsRef<[usize]>,

Required for Chunked and UniChunked subsets.

type Type = Subset<<S as View<'a>>::Type, &'a [usize]>

impl<'a, S, N> View<'a> for UniChunked<S, N>

where S: View<'a>, N: Copy,

type Type = UniChunked<<S as View<'a>>::Type, N>

impl<'a, S, O> View<'a> for Chunked<S, O>

where S: View<'a>, O: View<'a>,

type Type = Chunked<<S as View<'a>>::Type, <O as View<'a>>::Type>

impl<'a, S, T, I> View<'a> for Sparse<S, T, I>

where S: View<'a>, T: View<'a>, I: AsIndexSlice,

type Type = Sparse<<S as View<'a>>::Type, <T as View<'a>>::Type, &'a [usize]>

impl<'a, S> View<'a> for Select<S, Range<usize>>

where S: View<'a>,

type Type = Select<<S as View<'a>>::Type, Range<usize>>