Struct Used 

pub struct Used<T>(/* private fields */);

Helper type indicates that current element is included by the search result.

Trait Implementations

impl<First, Other, I> ConSubseq<Tuple<First, Unit>, Used<I>> for Tuple<First, Other>

where Other: ConSubseq<Unit, I>,

fn con_subseq(self) -> Tuple<First, Unit>

Take out a contiguous subsequence.

fn con_subseq_ref(&self) -> <Tuple<First, Unit> as TupleLike>::AsRefOutput<'_>

Similar to con_subseq(), but all its elements are immutable references to the supersequence’s elements.

fn con_subseq_mut( &mut self, ) -> <Tuple<First, Unit> as TupleLike>::AsMutOutput<'_>

Similar to con_subseq(), but all its elements are mutable references to the supersequence’s elements.

fn swap_con_subseq(&mut self, subseq: &mut Tuple<First, Unit>)

Swap elements with a contiguous subsequence.

fn replace_con_subseq(&mut self, subseq: Seq) -> Seq

Replace elements with a contiguous subsequence.

impl<First1, First2, Other1, Other2, I> ConSubseq<Tuple<First1, Tuple<First2, Other2>>, Used<I>> for Tuple<First1, Other1>

where Other1: ConSubseq<Tuple<First2, Other2>, Used<I>>, Other2: TupleLike,

fn con_subseq(self) -> Tuple<First1, Tuple<First2, Other2>>

Take out a contiguous subsequence.

fn con_subseq_ref( &self, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsRefOutput<'_>

Similar to con_subseq(), but all its elements are immutable references to the supersequence’s elements.

fn con_subseq_mut( &mut self, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsMutOutput<'_>

Similar to con_subseq(), but all its elements are mutable references to the supersequence’s elements.

fn swap_con_subseq(&mut self, subseq: &mut Tuple<First1, Tuple<First2, Other2>>)

Swap elements with a contiguous subsequence.

fn replace_con_subseq(&mut self, subseq: Seq) -> Seq

Replace elements with a contiguous subsequence.

impl<First, Other, F, I> ConSubseqMapReplace<Tuple<First, Unit>, F, Used<I>> for Tuple<First, Other>

where Other: ConSubseqMapReplace<Unit, <F as Mapper<First>>::NextMapper, I>, F: Mapper<First>,

type MapReplaceOutput = Tuple<<F as Mapper<First>>::Output, Other>

The type of tuple that replace elements of a specific contiguous subsequence to another sequence that may be of different element types.

fn map_replace_con_subseq(self, f: F) -> Self::MapReplaceOutput

Replace elements of specific contiguous subsequence with another sequence that may be of different element types.

impl<First1, First2, Other1, Other2, F, I> ConSubseqMapReplace<Tuple<First1, Tuple<First2, Other2>>, F, Used<I>> for Tuple<First1, Other1>

where Other1: ConSubseqMapReplace<Tuple<First2, Other2>, <F as Mapper<First1>>::NextMapper, Used<I>>, Other2: TupleLike, F: Mapper<First1>,

type MapReplaceOutput = Tuple<<F as Mapper<First1>>::Output, <Other1 as ConSubseqMapReplace<Tuple<First2, Other2>, <F as Mapper<First1>>::NextMapper, Used<I>>>::MapReplaceOutput>

The type of tuple that replace elements of a specific contiguous subsequence to another sequence that may be of different element types.

fn map_replace_con_subseq(self, f: F) -> Self::MapReplaceOutput

Replace elements of specific contiguous subsequence with another sequence that may be of different element types.

impl<First, Other1, Other2, I> Subseq<Tuple<First, Other2>, Used<I>> for Tuple<First, Other1>

where Other1: TupleLike + Subseq<Other2, I>, Other2: TupleLike,

fn subseq(self) -> Tuple<First, Other2>

Take out a subsequence.

fn subseq_ref(&self) -> <Tuple<First, Other2> as TupleLike>::AsRefOutput<'_>

Similar to subseq(), but all its elements are immutable references to the supersequence’s elements.

fn subseq_mut(&mut self) -> <Tuple<First, Other2> as TupleLike>::AsMutOutput<'_>

Similar to subseq(), but all its elements are mutable references to the supersequence’s elements.

fn swap_subseq(&mut self, subseq: &mut Tuple<First, Other2>)

Swap elements with a subsequence.

fn replace_subseq(&mut self, subseq: Seq) -> Seq

Replace elements with a subsequence.

impl<First, Other1, Other2, F, I> SubseqMapReplace<Tuple<First, Other2>, F, Used<I>> for Tuple<First, Other1>

where Other1: TupleLike + SubseqMapReplace<Other2, <F as Mapper<First>>::NextMapper, I>, Other2: TupleLike, F: Mapper<First>,

type MapReplaceOutput = Tuple<<F as Mapper<First>>::Output, <Other1 as SubseqMapReplace<Other2, <F as Mapper<First>>::NextMapper, I>>::MapReplaceOutput>

The type of tuple that replace elements of a specific subsequence to another sequence that may be of different element types.

fn map_replace_subseq(self, f: F) -> Self::MapReplaceOutput

Replace elements of specific subsequence with another sequence that may be of different element types.

impl<First, Other, I> UninitConSubseq<Tuple<First, Unit>, Used<I>> for Tuple<MaybeUninit<First>, Other>

where Other: UninitConSubseq<Unit, I>,

Available on crate feature uninit only.

type PartiallyInitialized = Tuple<First, Other>

The type of tuple consisting of elements not in the contiguous subsequence and values of each MaybeUninit elements in the contiguous subsequence.

unsafe fn assume_init_con_subseq(self) -> Self::PartiallyInitialized

Extract values of a specific contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_read_con_subseq(&self) -> Tuple<First, Unit>

Read the values of a specific contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_ref_con_subseq( &self, ) -> <Tuple<First, Unit> as TupleLike>::AsRefOutput<'_>

Get immutable references to values of a specific contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_mut_con_subseq( &mut self, ) -> <Tuple<First, Unit> as TupleLike>::AsMutOutput<'_>

Get mutable references to values of a specific contiguous subsequence consisting of MaybeUninit elements.

fn con_subseq_as_ptr(&self) -> <Tuple<First, Unit> as TupleLike>::AsPtrOutput

Get pointers to values of a specific contiguous subsequence consisting of MaybeUninit elements.

fn con_subseq_as_mut_ptr( &mut self, ) -> <Tuple<First, Unit> as TupleLike>::AsMutPtrOutput

Get mutable pointers to values of a specific contiguous subsequence consisting of MaybeUninit elements.

fn write_con_subseq( &mut self, subseq: Tuple<First, Unit>, ) -> <Tuple<First, Unit> as TupleLike>::AsMutOutput<'_>

Set values to a contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_drop_con_subseq(&mut self)

Drop values in place for a contiguous subsequence consisting of MaybeUninit elements.

impl<First1, First2, Other1, Other2, I> UninitConSubseq<Tuple<First1, Tuple<First2, Other2>>, Used<I>> for Tuple<MaybeUninit<First1>, Other1>

where Other1: UninitConSubseq<Tuple<First2, Other2>, Used<I>>, Other2: TupleLike,

Available on crate feature uninit only.

type PartiallyInitialized = Tuple<First1, <Other1 as UninitConSubseq<Tuple<First2, Other2>, Used<I>>>::PartiallyInitialized>

The type of tuple consisting of elements not in the contiguous subsequence and values of each MaybeUninit elements in the contiguous subsequence.

unsafe fn assume_init_con_subseq(self) -> Self::PartiallyInitialized

Extract values of a specific contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_read_con_subseq( &self, ) -> Tuple<First1, Tuple<First2, Other2>>

Read the values of a specific contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_ref_con_subseq( &self, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsRefOutput<'_>

Get immutable references to values of a specific contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_mut_con_subseq( &mut self, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsMutOutput<'_>

Get mutable references to values of a specific contiguous subsequence consisting of MaybeUninit elements.

fn con_subseq_as_ptr( &self, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsPtrOutput

Get pointers to values of a specific contiguous subsequence consisting of MaybeUninit elements.

fn con_subseq_as_mut_ptr( &mut self, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsMutPtrOutput

Get mutable pointers to values of a specific contiguous subsequence consisting of MaybeUninit elements.

fn write_con_subseq( &mut self, subseq: Tuple<First1, Tuple<First2, Other2>>, ) -> <Tuple<First1, Tuple<First2, Other2>> as TupleLike>::AsMutOutput<'_>

Set values to a contiguous subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_drop_con_subseq(&mut self)

Drop values in place for a contiguous subsequence consisting of MaybeUninit elements.

impl<First, Other1, Other2, I> UninitSubseq<Tuple<First, Other2>, Used<I>> for Tuple<MaybeUninit<First>, Other1>

where Other2: TupleLike, Other1: UninitSubseq<Other2, I>,

Available on crate feature uninit only.

type PartiallyInitialized = Tuple<First, <Other1 as UninitSubseq<Other2, I>>::PartiallyInitialized>

The type of tuple consisting of elements not in the subsequence and values of each MaybeUninit elements in the subsequence.

unsafe fn assume_init_subseq(self) -> Self::PartiallyInitialized

Extract values of a specific subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_read_subseq(&self) -> Tuple<First, Other2>

Read the values of a specific subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_ref_subseq( &self, ) -> <Tuple<First, Other2> as TupleLike>::AsRefOutput<'_>

Get immutable references to values of a specific subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_mut_subseq( &mut self, ) -> <Tuple<First, Other2> as TupleLike>::AsMutOutput<'_>

Get mutable references to values of a specific subsequence consisting of MaybeUninit elements.

fn subseq_as_ptr(&self) -> <Tuple<First, Other2> as TupleLike>::AsPtrOutput

Get pointers to values of a specific subsequence consisting of MaybeUninit elements.

fn subseq_as_mut_ptr( &mut self, ) -> <Tuple<First, Other2> as TupleLike>::AsMutPtrOutput

Get mutable pointers to values of a specific subsequence consisting of MaybeUninit elements.

fn write_subseq( &mut self, subseq: Tuple<First, Other2>, ) -> <Tuple<First, Other2> as TupleLike>::AsMutOutput<'_>

Set values to a subsequence consisting of MaybeUninit elements.

unsafe fn assume_init_drop_subseq(&mut self)

Drop values in place for a subsequence consisting of MaybeUninit elements.