Struct tuplez::Unit

pub struct Unit;

The unit type that represents tuples of zero elements.

Compared with Tuple type, the unit type does not implement the Poppable trait.

Suggestion: Use the parameterless tuple! macro to create a unit:

use tuplez::tuple;
let unit = tuple!();

Implementations

impl Unit

pub fn try_unwrap(self) -> Option<Self>

Available on crate feature unwrap only.

Always be Some(tuple!()).

Trait Implementations

impl<First, Other> Add<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the + operator.

fn add(self, _: &Unit) -> Self::Output

Performs the + operation.

impl<First, Other> Add<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the + operator.

fn add(self, _: &Unit) -> Self::Output

Performs the + operation.

impl<T> Add<T> for &Unit

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add<T> for Unit

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<First, Other> Add<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the + operator.

fn add(self, _: Unit) -> Self::Output

Performs the + operation.

impl<First, Other> Add<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the + operator.

fn add(self, _: Unit) -> Self::Output

Performs the + operation.

impl AddAssign<&Unit> for Unit

fn add_assign(&mut self, _: &Unit)

Performs the += operation.

impl AddAssign for Unit

fn add_assign(&mut self, _: Unit)

Performs the += operation.

impl AsDeref for Unit

type AsDerefOutput<'a> = Unit

The type of the output tuple.

fn as_deref(&self) -> Self::AsDerefOutput<'_>

Convert from &Tuple<T0, T1, T2, ...> to Tuple<&T0::Target, &T1::Target, &T2::Target, ..> while all the elements of the tuple implement Deref.

impl AsDerefMut for Unit

type AsDerefMutOutput<'a> = Unit

The type of the output tuple.

fn as_deref_mut(&mut self) -> Self::AsDerefMutOutput<'_>

Convert from &mut Tuple<T0, T1, T2, ...> to Tuple<&mut T0::Target, &mut T1::Target, &mut T2::Target, ..> while all the elements of the tuple implement DerefMut.

impl<First, Other> BitAnd<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the & operator.

fn bitand(self, _: &Unit) -> Self::Output

Performs the & operation.

impl<First, Other> BitAnd<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the & operator.

fn bitand(self, _: &Unit) -> Self::Output

Performs the & operation.

impl<T> BitAnd<T> for &Unit

type Output = T

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<T> BitAnd<T> for Unit

type Output = T

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<First, Other> BitAnd<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the & operator.

fn bitand(self, _: Unit) -> Self::Output

Performs the & operation.

impl<First, Other> BitAnd<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the & operator.

fn bitand(self, _: Unit) -> Self::Output

Performs the & operation.

impl BitAndAssign<&Unit> for Unit

fn bitand_assign(&mut self, _: &Unit)

Performs the &= operation.

impl BitAndAssign for Unit

fn bitand_assign(&mut self, _: Unit)

Performs the &= operation.

impl<First, Other> BitOr<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the | operator.

fn bitor(self, _: &Unit) -> Self::Output

Performs the | operation.

impl<First, Other> BitOr<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the | operator.

fn bitor(self, _: &Unit) -> Self::Output

Performs the | operation.

impl<T> BitOr<T> for &Unit

type Output = T

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<T> BitOr<T> for Unit

type Output = T

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<First, Other> BitOr<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the | operator.

fn bitor(self, _: Unit) -> Self::Output

Performs the | operation.

impl<First, Other> BitOr<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the | operator.

fn bitor(self, _: Unit) -> Self::Output

Performs the | operation.

impl BitOrAssign<&Unit> for Unit

fn bitor_assign(&mut self, _: &Unit)

Performs the |= operation.

impl BitOrAssign for Unit

fn bitor_assign(&mut self, _: Unit)

Performs the |= operation.

impl<First, Other> BitXor<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the ^ operator.

fn bitxor(self, _: &Unit) -> Self::Output

Performs the ^ operation.

impl<First, Other> BitXor<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the ^ operator.

fn bitxor(self, _: &Unit) -> Self::Output

Performs the ^ operation.

impl<T> BitXor<T> for &Unit

type Output = T

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<T> BitXor<T> for Unit

type Output = T

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<First, Other> BitXor<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the ^ operator.

fn bitxor(self, _: Unit) -> Self::Output

Performs the ^ operation.

impl<First, Other> BitXor<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the ^ operator.

fn bitxor(self, _: Unit) -> Self::Output

Performs the ^ operation.

impl BitXorAssign<&Unit> for Unit

fn bitxor_assign(&mut self, _: &Unit)

Performs the ^= operation.

impl BitXorAssign for Unit

fn bitxor_assign(&mut self, _: Unit)

Performs the ^= operation.

impl<T, P> Callable<T, P> for Unit

type Output = Unit

Type of the tuple collecting results of each call.

fn call(&self, _: T) -> Self::Output

When all elements of the tuple implement Fn(T) for a specific T, call them once in sequence.

impl Clone for Unit

fn clone(&self) -> Unit

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Cloned for Unit

type ClonedOutput = Unit

The type of the output tuple.

fn cloned(&self) -> Self::ClonedOutput

If the elements of the tuple are all references, clone these elements to a new tuple.

impl Combinable<Unit> for Unit

type CombineOutput = Unit

The type of the output generated by combine two tuples.

fn combine(self, _: Unit) -> Unit

If two tuples have the same number of elements, and their elements are both tuples, join their tuple elements one-to-one.

impl ConSubseq<Unit, Complete> for Unit

fn con_subseq(self) -> Unit

Take out a contiguous subsequence.

fn con_subseq_ref(&self) -> <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) -> <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, _: &mut Unit)

Swap elements with a contiguous subsequence.

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

Replace elements with a contiguous subsequence.

impl<F> ConSubseqMapReplace<Unit, F, Complete> for Unit

type MapReplaceOutput = Unit

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) -> Self::MapReplaceOutput

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

impl Copied for Unit

type CopiedOutput = Unit

The type of the output tuple.

fn copied(&self) -> Self::CopiedOutput

If the elements of the tuple are all references, copy its elements to a new tuple.

impl Debug for Unit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Unit

fn default() -> Unit

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Unit

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<First, Other> Div<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the / operator.

fn div(self, _: &Unit) -> Self::Output

Performs the / operation.

impl<First, Other> Div<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the / operator.

fn div(self, _: &Unit) -> Self::Output

Performs the / operation.

impl<T> Div<T> for &Unit

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Div<T> for Unit

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<First, Other> Div<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the / operator.

fn div(self, _: Unit) -> Self::Output

Performs the / operation.

impl<First, Other> Div<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the / operator.

fn div(self, _: Unit) -> Self::Output

Performs the / operation.

impl DivAssign<&Unit> for Unit

fn div_assign(&mut self, _: &Unit)

Performs the /= operation.

impl DivAssign for Unit

fn div_assign(&mut self, _: Unit)

Performs the /= operation.

impl Dot for Unit

type Output = Unit

Output type of the dot product operation.

fn dot(self, _: Self) -> Self::Output

Performs the dot product operation.

impl Enumerable for Unit

type EnumerateOutput = Unit

The type of the output tuple.

fn enumerate(self, _: usize) -> Self::EnumerateOutput

Convert from tuple!(x, y, z, ...) to tuple!((0, x), (1, y), (2, z), ...).

impl Extendable<Unit> for Unit

type ExtendFrontOutput = Unit

The type of the output generated by pushing new elements to the front of tuple elements.

type ExtendBackOutput = Unit

The type of the output generated by pushing new elements to the back of tuple elements.

fn extend(self, _: Unit) -> Self::ExtendBackOutput

If the elements of a tuple are all tuples, push an element to the back of each tuple element.

fn extend_front(self, _: Unit) -> Self::ExtendFrontOutput

If the elements of a tuple are all tuples, push an element to the front of each tuple element.

fn extend_back(self, rhs: T) -> Self::ExtendBackOutput

where Self: Sized,

If the elements of a tuple are all tuples, push an element to the front of each tuple element. Same as extend().

impl<F, Acc> Foldable<F, Acc> for Unit

type Output = Acc

The type of the output generated by folding the tuple.

fn fold(self, _: F, acc: Acc) -> Self::Output

Fold the tuple.

impl<F> Foreach<F> for Unit

type Output = Unit

The type of tuple generated by traversing the tuple.

fn foreach(self, _: F) -> Self::Output

Traverse the tuple, and collect the output of traversal into a new tuple.

impl<T> From<[T; 0]> for Unit

fn from(_: [T; 0]) -> Self

Converts to this type from the input type.

impl From<()> for Unit

fn from(_: ()) -> Self

Converts to this type from the input type.

impl Hash for Unit

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<First, Other> Mul<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the * operator.

fn mul(self, _: &Unit) -> Self::Output

Performs the * operation.

impl<First, Other> Mul<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the * operator.

fn mul(self, _: &Unit) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for &Unit

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for Unit

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<First, Other> Mul<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the * operator.

fn mul(self, _: Unit) -> Self::Output

Performs the * operation.

impl<First, Other> Mul<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the * operator.

fn mul(self, _: Unit) -> Self::Output

Performs the * operation.

impl MulAssign<&Unit> for Unit

fn mul_assign(&mut self, _: &Unit)

Performs the *= operation.

impl MulAssign for Unit

fn mul_assign(&mut self, _: Unit)

Performs the *= operation.

impl<T, P> MutCallable<T, P> for Unit

type Output = Unit

Type of the tuple collecting results of each call.

fn call_mut(&mut self, _: T) -> Self::Output

When all elements of the tuple implement FnMut(T) for a specific T, call them once in sequence.

impl Neg for &Unit

type Output = Unit

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Unit

type Output = Unit

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &Unit

type Output = Unit

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Unit

type Output = Unit

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, P> OnceCallable<T, P> for Unit

type Output = Unit

Type of the tuple collecting results of each call.

fn call_once(self, _: T) -> Self::Output

When all elements of the tuple implement FnOnce(T) for a specific T, call them once in sequence.

impl Ord for Unit

fn cmp(&self, other: &Unit) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl Owned for Unit

type OwnedOutput = Unit

Available on crate features std or alloc only.

The type of the output tuple.

fn owned(&self) -> Self::OwnedOutput

Available on crate features std or alloc only.

If the elements of the tuple are all references, clone its elements to a new tuple.

impl PartialEq for Unit

fn eq(&self, other: &Unit) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Unit

fn partial_cmp(&self, other: &Unit) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<First, Other> Rem<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the % operator.

fn rem(self, _: &Unit) -> Self::Output

Performs the % operation.

impl<First, Other> Rem<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the % operator.

fn rem(self, _: &Unit) -> Self::Output

Performs the % operation.

impl<T> Rem<T> for &Unit

type Output = T

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T> Rem<T> for Unit

type Output = T

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<First, Other> Rem<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the % operator.

fn rem(self, _: Unit) -> Self::Output

Performs the % operation.

impl<First, Other> Rem<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the % operator.

fn rem(self, _: Unit) -> Self::Output

Performs the % operation.

impl RemAssign<&Unit> for Unit

fn rem_assign(&mut self, _: &Unit)

Performs the %= operation.

impl RemAssign for Unit

fn rem_assign(&mut self, _: Unit)

Performs the %= operation.

impl Rotatable for Unit

type RotLeftOutput = Unit

The type of tuple generated by left rotating the elements of the tuple.

type RotRightOutput = Unit

The type of tuple generated by right rotating the elements of the tuple.

fn rot_l(self) -> Unit

Left rotates the elements of the tuple.

fn rot_r(self) -> Unit

Right rotates the elements of the tuple.

impl Serialize for Unit

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<First, Other> Shl<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the << operator.

fn shl(self, _: &Unit) -> Self::Output

Performs the << operation.

impl<First, Other> Shl<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the << operator.

fn shl(self, _: &Unit) -> Self::Output

Performs the << operation.

impl<T> Shl<T> for &Unit

type Output = T

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<T> Shl<T> for Unit

type Output = T

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<First, Other> Shl<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the << operator.

fn shl(self, _: Unit) -> Self::Output

Performs the << operation.

impl<First, Other> Shl<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the << operator.

fn shl(self, _: Unit) -> Self::Output

Performs the << operation.

impl ShlAssign<&Unit> for Unit

fn shl_assign(&mut self, _: &Unit)

Performs the <<= operation.

impl ShlAssign for Unit

fn shl_assign(&mut self, _: Unit)

Performs the <<= operation.

impl<First, Other> Shr<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the >> operator.

fn shr(self, _: &Unit) -> Self::Output

Performs the >> operation.

impl<First, Other> Shr<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the >> operator.

fn shr(self, _: &Unit) -> Self::Output

Performs the >> operation.

impl<T> Shr<T> for &Unit

type Output = T

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<T> Shr<T> for Unit

type Output = T

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<First, Other> Shr<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the >> operator.

fn shr(self, _: Unit) -> Self::Output

Performs the >> operation.

impl<First, Other> Shr<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the >> operator.

fn shr(self, _: Unit) -> Self::Output

Performs the >> operation.

impl ShrAssign<&Unit> for Unit

fn shr_assign(&mut self, _: &Unit)

Performs the >>= operation.

impl ShrAssign for Unit

fn shr_assign(&mut self, _: Unit)

Performs the >>= operation.

impl Shrinkable for Unit

type ShrinkFrontOutput = Unit

The type of the output generated by pop elements from the front of tuple elements.

type ShrinkFrontElements = Unit

The type of the tuple that collect popped elements from the front of tuple elements.

type ShrinkBackOutput = Unit

The type of the output generated by pop elements from the back of tuple elements.

type ShrinkBackElements = Unit

The type of the tuple that collect popped elements from the back of tuple elements.

fn shrink(self) -> (Unit, Unit)

If the elements of a tuple are all tuples, pop an element from the back of each tuple element.

fn shrink_front(self) -> (Self::ShrinkFrontOutput, Self::ShrinkFrontElements)

If the elements of a tuple are all tuples, pop an element from the front of each tuple element.

fn shrink_back(self) -> (Self::ShrinkBackOutput, Self::ShrinkBackElements)

where Self: Sized,

If the elements of a tuple are all tuples, pop an element from the back of each tuple element. Same as shrink().

impl<First, Other> Sub<&Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the - operator.

fn sub(self, _: &Unit) -> Self::Output

Performs the - operation.

impl<First, Other> Sub<&Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the - operator.

fn sub(self, _: &Unit) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for &Unit

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for Unit

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<First, Other> Sub<Unit> for &Tuple<First, Other>

where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the - operator.

fn sub(self, _: Unit) -> Self::Output

Performs the - operation.

impl<First, Other> Sub<Unit> for Tuple<First, Other>

where Other: TupleLike,

type Output = Tuple<First, Other>

The resulting type after applying the - operator.

fn sub(self, _: Unit) -> Self::Output

Performs the - operation.

impl SubAssign<&Unit> for Unit

fn sub_assign(&mut self, _: &Unit)

Performs the -= operation.

impl SubAssign for Unit

fn sub_assign(&mut self, _: Unit)

Performs the -= operation.

impl Subseq<Unit, Complete> for Unit

fn subseq(self) -> Unit

Take out a subsequence.

fn subseq_ref(&self) -> <Unit as TupleLike>::AsRefOutput<'_>

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

fn subseq_mut(&mut self) -> <Unit as TupleLike>::AsMutOutput<'_>

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

fn swap_subseq(&mut self, _: &mut Unit)

Swap elements with a subsequence.

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

Replace elements with a subsequence.

impl<F> SubseqMapReplace<Unit, F, Complete> for Unit

type MapReplaceOutput = Unit

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) -> Self::MapReplaceOutput

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

impl<Pred> TestAll<Pred> for Unit

fn all(&self, _: Pred) -> bool

Tests if every element of the tuple matches a predicate.

impl<Pred> TestAny<Pred> for Unit

fn any(&self, _: Pred) -> bool

Tests if any element of the tuple matches a predicate.

impl<T> ToArray<T> for Unit

type Array = [T; 0]

The primitive array type to generate.

type Iter<'a> = IntoIter<&'a T, 0> where Self: 'a, T: 'a

Immutable element iterator type.

type IterMut<'a> = IntoIter<&'a mut T, 0> where Self: 'a, T: 'a

Mutable element iterator type.

fn to_array(self) -> Self::Array

Convert from the tuple to the primitive array.

fn iter<'a>(&'a self) -> Self::Iter<'a>

where Self: 'a, T: 'a,

Get immutable element iterator.

fn iter_mut<'a>(&'a mut self) -> Self::IterMut<'a>

where Self: 'a, T: 'a,

Get mutable element iterator.

impl ToPrimitive for Unit

type Primitive = ()

The primitive tuple type containing the same number and order of elements.

fn primitive(self) -> Self::Primitive

Convert from the tuple to the primitive tuple.

impl TupleLike for Unit

type AsRefOutput<'a> = Unit

The type of tuple containing immutable references to all elements of the tuple.

type AsMutOutput<'a> = Unit

The type of tuple containing mutable references to all elements of the tuple.

type AsPtrOutput = Unit

The type of tuple containing pointers to all elements of the tuple.

type AsMutPtrOutput = Unit

The type of tuple containing mutable pointers to all elements of the tuple.

type AsPinRefOutput<'a> = Unit

The type of tuple containing Pins of immutable references to all elements of the tuple.

type AsPinMutOutput<'a> = Unit

The type of tuple containing Pins of mutable references to all elements of the tuple.

type PushFrontOutput<T> = Tuple<T, Unit>

The type of tuple generated by pushing an element to the front of the tuple.

type PushBackOutput<T> = Tuple<T, Unit>

The type of tuple generated by pushing an element to the back of the tuple.

type RevOutput = Unit

The type of tuple generated by reversing the tuple.

type JoinOutput<T> = T where T: TupleLike

The type of tuple generated by joining two tuples.

type ToSomeOutput = Unit

The type of tuple after wrapping all elements into Option.

type ToOkOutput<E> = Unit

The type of tuple after wrapping all elements into Result.

type ToTupleOutput = Unit

The type of tuple after wrapping all elements into Tuple.

type Uninit = Unit

Available on crate feature uninit only.

The type of tuple after wrapping all elements into MaybeUninit.

const LEN: usize = 0usize

The number of elements in the tuple.

fn as_ref(&self) -> Self::AsRefOutput<'_>

Generate a tuple containing immutable references to all elements of the tuple.

fn as_mut(&mut self) -> Self::AsMutOutput<'_>

Generate a tuple containing mutable reference to all elements of the tuple.

fn as_ptr(&self) -> Self::AsPtrOutput

Generate a tuple containing pointers to all elements of the tuple.

fn as_mut_ptr(&mut self) -> Self::AsMutPtrOutput

Generate a tuple containing mutable pointers to all elements of the tuple.

fn as_pin_ref(self: Pin<&Self>) -> Self::AsPinRefOutput<'_>

Convert from Pin<&Tuple<T0, T1, T2, ..> to Tuple<Pin<&T0>, Pin<&T1>, Pin<&T2>, ...>.

fn as_pin_mut(self: Pin<&mut Self>) -> Self::AsPinMutOutput<'_>

Convert from Pin<&mut Tuple<T0, T1, T2, ..> to Tuple<Pin<&mut T0>, Pin<&mut T1>, Pin<&mut T2>, ...>.

fn push<T>(self, value: T) -> Self::PushBackOutput<T>

Push an element to the back of the tuple.

fn push_front<T>(self, value: T) -> Self::PushFrontOutput<T>

Push an element to the front of the tuple.

fn push_back<T>(self, value: T) -> Self::PushBackOutput<T>

Push an element to the back of the tuple. Same as push().

fn rev(self) -> Self::RevOutput

Reverse elements of the tuple.

fn join<T>(self, value: T) -> Self::JoinOutput<T>

where T: TupleLike,

Join two tuples.

fn to_some(self) -> Self::ToSomeOutput

Convert from tuple!(a, b, c ...) to tuple!(Some(a), Some(b), Some(c) ...).

fn to_ok<E>(self) -> Self::ToOkOutput<E>

Convert from tuple!(a, b, c ...) to tuple!(Ok(a), Ok(b), Ok(c) ...).

fn to_tuple(self) -> Self::ToTupleOutput

Convert from tuple!(a, b, c ...) to tuple!(tuple!(a), tuple!(b), tuple!(c) ...).

fn uninit() -> Self::Uninit

Available on crate feature uninit only.

Create a new tuple that all elements are wrapped by MaybeUninit and in uninitialized states.

fn zeroed() -> Self::Uninit

Available on crate feature uninit only.

Create a new tuple that all elements are wrapped by MaybeUninit and in uninitialized states, with the memory being filled with 0 bytes.

fn to_uninit(self) -> Self::Uninit

Available on crate feature uninit only.

Convert from tuple!(a, b, c ...) to tuple!(MaybeUninit::new(a), MaybeUninit::new(b), MaybeUninit::new(c) ...).

fn len(&self) -> usize

Get the number of elements in the tuple. MUST always return LEN.

fn is_empty(&self) -> bool

Check if tuple is empty.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance.

fn enumerate(self) -> Self::EnumerateOutput

where Self: Sized + Enumerable,

Convert from tuple!(x, y, z, ...) to tuple!((0, x), (1, y), (2, z), ...).

fn take<T, I>(self) -> (T, Self::TakeRemainder)

where Self: Search<T, I> + Sized,

Take out the searched element, and get the remainder of tuple.

fn get_ref<T, I>(&self) -> &T

where Self: Search<T, I> + Sized,

Get an immutable reference of the searched element.

fn get_mut<T, I>(&mut self) -> &mut T

where Self: Search<T, I> + Sized,

Get a mutable reference of the searched element.

fn swap<T, I>(&mut self, value: &mut T)

where Self: Search<T, I>,

Swap a specific element of the same type with another value.

fn replace<T, I>(&mut self, value: T) -> T

where Self: Search<T, I>,

Replace a specific element of the same type with another value.

fn map_replace<T, U, F, I>(self, f: F) -> Self::MapReplaceOutput<U>

where Self: Search<T, I> + Sized, F: FnOnce(T) -> U,

Replace a specific element with another value that may be of a different type.

fn subseq<Seq, I>(self) -> Seq

where Self: Subseq<Seq, I> + Sized, Seq: TupleLike,

Take out a subsequence.

fn subseq_ref<Seq, I>(&self) -> Seq::AsRefOutput<'_>

where Self: Subseq<Seq, I> + Sized, Seq: TupleLike,

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

fn subseq_mut<Seq, I>(&mut self) -> Seq::AsMutOutput<'_>

where Self: Subseq<Seq, I> + Sized, Seq: TupleLike,

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

fn swap_subseq<Seq, I>(&mut self, subseq: &mut Seq)

where Seq: TupleLike, Self: Subseq<Seq, I>,

Swap elements with a subsequence.

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

where Seq: TupleLike, Self: Subseq<Seq, I>,

Replace elements with a subsequence.

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

where Seq: TupleLike, Self: SubseqMapReplace<Seq, F, I> + Sized,

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

fn foreach_subseq<Seq, F, I>(self, f: F) -> Self::MapReplaceOutput

where Seq: TupleLike, Self: SubseqMapReplace<Seq, F, I> + Sized,

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

fn con_subseq<Seq, I>(self) -> Seq

where Seq: TupleLike, Self: ConSubseq<Seq, I> + Sized,

Take out a contiguous subsequence.

fn con_subseq_ref<Seq, I>(&self) -> Seq::AsRefOutput<'_>

where Seq: TupleLike, Self: ConSubseq<Seq, I>,

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

fn con_subseq_mut<Seq, I>(&mut self) -> Seq::AsMutOutput<'_>

where Seq: TupleLike, Self: ConSubseq<Seq, I>,

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

fn swap_con_subseq<Seq, I>(&mut self, subseq: &mut Seq)

where Seq: TupleLike, Self: ConSubseq<Seq, I>,

Swap elements with a contiguous subsequence.

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

where Seq: TupleLike, Self: ConSubseq<Seq, I>,

Replace elements with a contiguous subsequence.

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

where Seq: TupleLike, Self: ConSubseqMapReplace<Seq, F, I> + Sized,

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

fn foreach_con_subseq<Seq, F, I>(self, f: F) -> Self::MapReplaceOutput

where Seq: TupleLike, Self: ConSubseqMapReplace<Seq, F, I> + Sized,

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

fn subset<Seq, I>(self) -> Seq

where Self: Subseq<Seq, I> + Sized, Seq: TupleLike,

👎Deprecated since 0.10.0: Use subseq() or con_subseq() instead

In the past it was used for the functionality of subseq(), however it did not live up to its name: you actually got a subsequence not a subset while subsets are not required to maintain a consistent element order as the superset.

fn subset_ref<Seq, I>(&self) -> Seq::AsRefOutput<'_>

where Self: Subseq<Seq, I> + Sized, Seq: TupleLike,

👎Deprecated since 0.10.0: Use subseq_ref() or con_subseq_ref() instead

In the past it was used for the functionality of subseq_ref(), however it did not live up to its name: you actually got a subsequence not a subset while subsets are not required to maintain a consistent element order as the superset.

fn subset_mut<Seq, I>(&mut self) -> Seq::AsMutOutput<'_>

where Self: Subseq<Seq, I> + Sized, Seq: TupleLike,

👎Deprecated since 0.10.0: Use subseq_mut() or con_subseq_mut() instead

In the past it was used for the functionality of subseq_mut(), however it did not live up to its name: you actually got a subsequence not a subset while subsets are not required to maintain a consistent element order as the superset.

fn swap_with<Seq, I>(&mut self, subseq: &mut Seq)

where Seq: TupleLike, Self: ConSubseq<Seq, I>,

👎Deprecated since 0.10.0: Use swap(), swap_subseq() or swap_con_subseq() instead

In the past it was used for the functionality of swap_con_subseq(), but with the addition of swap_subseq(), the functionality of this method becomes very unclear.

fn replace_with<Seq, I>(&mut self, subseq: Seq) -> Seq

where Seq: TupleLike, Self: ConSubseq<Seq, I>,

👎Deprecated since 0.10.0: Use replace(), replace_subseq() or replace_con_subseq() instead

In the past it was used for the functionality of replace_con_subseq(), but with the addition of replace_subseq(), the functionality of this method becomes very unclear.

fn as_deref(&self) -> Self::AsDerefOutput<'_>

where Self: AsDeref,

Convert from &Tuple<T0, T1, T2, ...> to Tuple<&T0::Target, &T1::Target, &T2::Target, ..> while all the elements of the tuple implement Deref.

fn as_deref_mut(&mut self) -> Self::AsDerefMutOutput<'_>

where Self: AsDerefMut,

Convert from &mut Tuple<T0, T1, T2, ...> to Tuple<&mut T0::Target, &mut T1::Target, &mut T2::Target, ..> while all the elements of the tuple implement DerefMut.

fn cloned(&self) -> Self::ClonedOutput

where Self: Cloned,

If the elements of the tuple are all references, clone its elements to a new tuple.

fn copied(&self) -> Self::CopiedOutput

where Self: Copied,

If the elements of the tuple are all references, copy its elements to a new tuple.

fn owned(&self) -> Self::OwnedOutput

where Self: Owned,

Available on crate features std or alloc only.

If the elements of the tuple are all references, clone its elements to a new tuple.

fn rot_l(self) -> Self::RotLeftOutput

where Self: Rotatable + Sized,

Left rotates the elements of the tuple.

fn rot_r(self) -> Self::RotRightOutput

where Self: Rotatable + Sized,

Right rotates the elements of the tuple.

unsafe fn uninit_assume_init(self) -> Self::Initialized

where Self: Uninit + Sized,

Available on crate feature uninit only.

Extract the values of a tuple consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_one<T, I>(self) -> Self::MapReplaceOutput<T>

where Self: Search<MaybeUninit<T>, I> + Sized,

Available on crate feature uninit only.

Extract value from a specific MaybeUninit element.

unsafe fn uninit_assume_init_read(&self) -> Self::Initialized

where Self: Uninit,

Available on crate feature uninit only.

Read the values of a tuple consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_read_one<T, I>(&self) -> T

where Self: Search<MaybeUninit<T>, I>,

Available on crate feature uninit only.

Read one value from a specific MaybeUninit element.

unsafe fn uninit_assume_init_ref( &self, ) -> <Self::Initialized as TupleLike>::AsRefOutput<'_>

where Self: Uninit,

Available on crate feature uninit only.

Get immutable references to values of a tuple consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_ref_one<T, I>(&self) -> &T

where Self: Search<MaybeUninit<T>, I>,

Available on crate feature uninit only.

Get immutable reference to value of a specific MaybeUninit element.

unsafe fn uninit_assume_init_mut( &mut self, ) -> <Self::Initialized as TupleLike>::AsMutOutput<'_>

where Self: Uninit,

Available on crate feature uninit only.

Get mutable references to values of a tuple consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_mut_one<T, I>(&mut self) -> &mut T

where Self: Search<MaybeUninit<T>, I>,

Available on crate feature uninit only.

Get mutable reference to value of a specific MaybeUninit element.

unsafe fn uninit_assume_init_drop(&mut self)

where Self: Uninit,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_drop_one<T, I>(&mut self)

where Self: Search<MaybeUninit<T>, I>,

Available on crate feature uninit only.

Drop value in place for a specific MaybeUninit element.

fn uninit_as_ptr(&self) -> <Self::Initialized as TupleLike>::AsPtrOutput

where Self: Uninit,

Available on crate feature uninit only.

Get points to values of a tuple consisting of MaybeUninit elements.

fn uninit_as_mut_ptr( &mut self, ) -> <Self::Initialized as TupleLike>::AsMutPtrOutput

where Self: Uninit,

Available on crate feature uninit only.

Get mutable points to values of a tuple consisting of MaybeUninit elements.

fn uninit_write_one<T, I>(&mut self, value: T) -> &mut T

where Self: Search<MaybeUninit<T>, I>,

Available on crate feature uninit only.

Set value to a specific MaybeUninit element in a tuple.

fn uninit_write( &mut self, init: Self::Initialized, ) -> <Self::Initialized as TupleLike>::AsMutOutput<'_>

where Self: Uninit,

Available on crate feature uninit only.

Set values to a tuple consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_subseq<Seq, I>(self) -> Self::PartiallyInitialized

where Seq: TupleLike, Self: UninitSubseq<Seq, I> + Sized,

Available on crate feature uninit only.

Extract values of a specific subsequence consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_read_subseq<Seq, I>(&self) -> Seq

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_ref_subseq<Seq, I>( &self, ) -> <Seq as TupleLike>::AsRefOutput<'_>

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_mut_subseq<Seq, I>( &mut self, ) -> <Seq as TupleLike>::AsMutOutput<'_>

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn uninit_subseq_as_ptr<Seq, I>(&self) -> <Seq as TupleLike>::AsPtrOutput

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn uninit_subseq_as_mut_ptr<Seq, I>( &mut self, ) -> <Seq as TupleLike>::AsMutPtrOutput

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn uninit_write_subseq<Seq, I>(&mut self, subseq: Seq) -> Seq::AsMutOutput<'_>

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

Set values to a subsequence consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_drop_subseq<Seq, I>(&mut self)

where Seq: TupleLike, Self: UninitSubseq<Seq, I>,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_con_subseq<Seq, I>( self, ) -> Self::PartiallyInitialized

where Seq: TupleLike, Self: UninitConSubseq<Seq, I> + Sized,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_read_con_subseq<Seq, I>(&self) -> Seq

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_ref_con_subseq<Seq, I>( &self, ) -> <Seq as TupleLike>::AsRefOutput<'_>

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

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

unsafe fn uninit_assume_init_mut_con_subseq<Seq, I>( &mut self, ) -> <Seq as TupleLike>::AsMutOutput<'_>

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn uninit_con_subseq_as_ptr<Seq, I>(&self) -> <Seq as TupleLike>::AsPtrOutput

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn uninit_con_subseq_as_mut_ptr<Seq, I>( &mut self, ) -> <Seq as TupleLike>::AsMutPtrOutput

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn uninit_write_con_subseq<Seq, I>( &mut self, subseq: Seq, ) -> Seq::AsMutOutput<'_>

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

Set values to a contiguous subsequence consisting of MaybeUninit elements.

unsafe fn uninit_assume_init_drop_con_subseq<Seq, I>(&mut self)

where Seq: TupleLike, Self: UninitConSubseq<Seq, I>,

Available on crate feature uninit only.

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

fn untuple(self) -> Self::UntupleOutput

where Self: Untupleable + Sized,

Untuple a tuple, whose elements are all tuples.

fn flatten(self) -> Self::UntupleOutput

where Self: Untupleable + Sized,

Flatten one level of nesting in the tuple.

fn foreach<F>(self, mapper: F) -> <Self as Foreach<F>>::Output

where Self: Foreach<F> + Sized,

Traverse the tuple, and collect the output of traversal into a new tuple.

fn fold<F, Acc>(self, folder: F, acc: Acc) -> <Self as Foldable<F, Acc>>::Output

where Self: Foldable<F, Acc> + Sized,

Fold the tuple.

fn any<Pred>(&self, predicate: Pred) -> bool

where Self: TestAny<Pred>,

Tests if any element of the tuple matches a predicate.

fn all<Pred>(&self, predicate: Pred) -> bool

where Self: TestAll<Pred>,

Tests if every element of the tuple matches a predicate.

fn dot<T>(self, rhs: T) -> <Self as Dot<T>>::Output

where Self: Dot<T> + Sized,

Performs dot product operation.

fn zip<T>(self, rhs: T) -> Self::ZipOutput

where Self: Zippable<T> + Sized,

Zip two tuples.

fn zip2<T>(self, rhs: T) -> Self::ZipOutput2

where Self: Zippable<T> + Sized,

Zip two tuples, but output elements are primitive tuples.

fn unzip(self) -> (Self::UnzipOutputLeft, Self::UnzipOutputRight)

where Self: Unzippable + Sized,

Unzip a tuple to two tuples, if all elements of the tuple are tuples with two elements. Elements can be of Tuple type or primitive tuple type.

fn extend<T>(self, rhs: T) -> Self::ExtendBackOutput

where Self: Extendable<T> + Sized,

If the elements of a tuple are all tuples, push an element to the back of each tuple element.

fn extend_front<T>(self, rhs: T) -> Self::ExtendFrontOutput

where Self: Extendable<T> + Sized,

If the elements of a tuple are all tuples, push an element to the front of each tuple element.

fn extend_back<T>(self, rhs: T) -> Self::ExtendBackOutput

where Self: Extendable<T> + Sized,

If the elements of a tuple are all tuples, push an element to the front of each tuple element. Same as extend().

fn shrink(self) -> (Self::ShrinkBackOutput, Self::ShrinkBackElements)

where Self: Shrinkable + Sized,

If the elements of a tuple are all tuples, pop an element from the back of each tuple element.

fn shrink_front(self) -> (Self::ShrinkFrontOutput, Self::ShrinkFrontElements)

where Self: Shrinkable + Sized,

If the elements of a tuple are all tuples, pop an element from the front of each tuple element.

fn shrink_back(self) -> (Self::ShrinkBackOutput, Self::ShrinkBackElements)

where Self: Shrinkable + Sized,

If the elements of a tuple are all tuples, pop an element from the back of each tuple element. Same as shrink().

fn combine<T>(self, rhs: T) -> Self::CombineOutput

where Self: Combinable<T> + Sized,

If two tuples have the same number of elements, and their elements are both tuples, join their tuple elements one-to-one.

fn replace_head<T>(self, rhs: T) -> (Self::ReplaceOutput, Self::Replaced)

where T: TupleLike, Self: HeadReplaceable<T> + Sized,

Replace the first N elements of the tuple with all elements of another tuple of N elements.

fn replace_tail<T, I>(self, rhs: T) -> (Self::ReplaceOutput, Self::Replaced)

where T: TupleLike, Self: TailReplaceable<T, I> + Sized,

Replace the last N elements of the tuple with all elements of another tuple of N elements.

fn call<T, P>(&self, rhs: T) -> <Self as Callable<T, P>>::Output

where Self: Callable<T, P>,

When all elements of the tuple implement Fn(T) for a specific T, call them once in sequence.

fn call_mut<T, P>(&mut self, rhs: T) -> <Self as MutCallable<T, P>>::Output

where Self: MutCallable<T, P>,

When all elements of the tuple implement FnMut(T) for a specific T, call them once in sequence.

fn call_once<T, P>(self, rhs: T) -> <Self as OnceCallable<T, P>>::Output

where Self: OnceCallable<T, P> + Sized,

When all elements of the tuple implement FnOnce(T) for a specific T, call them once in sequence.

fn unwrap(self) -> Self::UnwrapOutput

where Self: Unwrap + Sized,

Available on crate feature unwrap only.

Convert from Tuple<Wrapper0<T0>, Wrapper1<T1>, ... Wrappern<Tn>> to Tuple<T0, T1, ..., Tn>, when all element types Wrapper0, Wrapper1 … Wrappern implement Unwrap.

fn has_value(&self) -> bool

where Self: Unwrap,

Available on crate feature unwrap only.

Check if self can be safely unwrap().

fn unwrap_or_default(self) -> Self::UnwrapOutput

where Self: UnwrapOrDefault + Sized,

Available on crate feature unwrap only.

Convert from Tuple<Wrapper0<T0>, Wrapper1<T1>, ... Wrappern<Tn>> to Tuple<T0, T1, ..., Tn>, when all element types Wrapper0, Wrapper1 … Wrappern implement UnwrapOrDefault.

fn try_unwrap(self) -> Option<Self::UnwrapOutput>

where Self: Unwrap + Sized,

Available on crate feature unwrap only.

Convert from Tuple<Wrapper0<T0>, Wrapper1<T1>, ... Wrappern<Tn>> to Option<Tuple<T0, T1, ..., Tn>>, when all element types Wrapper0, Wrapper1 … Wrappern implement Unwrap.

impl Uninit for Unit

Available on crate feature uninit only.

type Initialized = Unit

The type of the tuple consisting of values of each MaybeUninit elements.

unsafe fn assume_init(self) -> Self::Initialized

Extract the values of a tuple consisting of MaybeUninit elements.

unsafe fn assume_init_read(&self) -> Self::Initialized

Read the values of a tuple consisting of MaybeUninit elements.

unsafe fn assume_init_ref( &self, ) -> <Self::Initialized as TupleLike>::AsRefOutput<'_>

Get immutable references to values of a tuple consisting of MaybeUninit elements.

unsafe fn assume_init_mut( &mut self, ) -> <Self::Initialized as TupleLike>::AsMutOutput<'_>

Get mutable references to values of a tuple consisting of MaybeUninit elements.

unsafe fn assume_init_drop(&mut self)

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

fn as_ptr(&self) -> <Self::Initialized as TupleLike>::AsPtrOutput

Get points to values of a tuple consisting of MaybeUninit elements.

fn as_mut_ptr(&mut self) -> <Self::Initialized as TupleLike>::AsMutPtrOutput

Get mutable points to values of a tuple consisting of MaybeUninit elements.

fn write( &mut self, _: Self::Initialized, ) -> <Self::Initialized as TupleLike>::AsMutOutput<'_>

Set values to a tuple consisting of MaybeUninit elements.

impl UninitConSubseq<Unit, Complete> for Unit

Available on crate feature uninit only.

type PartiallyInitialized = Unit

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) -> Unit

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

unsafe fn assume_init_ref_con_subseq( &self, ) -> <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, ) -> <Unit as TupleLike>::AsMutOutput<'_>

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

fn con_subseq_as_ptr(&self) -> <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) -> <Unit as TupleLike>::AsMutPtrOutput

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

fn write_con_subseq(&mut self, _: Unit) -> <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 UninitSubseq<Unit, Complete> for Unit

Available on crate feature uninit only.

type PartiallyInitialized = Unit

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) -> Unit

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

unsafe fn assume_init_ref_subseq(&self) -> <Unit as TupleLike>::AsRefOutput<'_>

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

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

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

fn subseq_as_ptr(&self) -> <Unit as TupleLike>::AsPtrOutput

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

fn subseq_as_mut_ptr(&mut self) -> <Unit as TupleLike>::AsMutPtrOutput

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

fn write_subseq(&mut self, _: Unit) -> <Unit 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.

impl Untupleable for Unit

type UntupleOutput = Unit

The type of tuple generated by untupling the elements of the tuple.

fn untuple(self) -> Self::UntupleOutput

Untuple a tuple, whose elements are all tuples with only one element.

impl Unwrap for Unit

Available on crate feature unwrap only.

type UnwrapOutput = Unit

Type of the contained value.

fn unwrap(self) -> Self::UnwrapOutput

Get the contained value.

fn has_value(&self) -> bool

Check if self contains a value.

impl UnwrapOrDefault for Unit

Available on crate feature unwrap only.

type UnwrapOutput = Unit

Type of the contained value.

fn unwrap_or_default(self) -> Self::UnwrapOutput

Get the contained value, or the default value if self does not contain a value.

impl Unzippable for Unit

type UnzipOutputLeft = Unit

The type of the new tuple which collects all first elements of the tuple elements.

type UnzipOutputRight = Unit

The type of the new tuple which collects all second elements of the tuple elements.

fn unzip(self) -> (Self::UnzipOutputLeft, Self::UnzipOutputRight)

Unzip a tuple to two tuples, if all elements of the tuple are tuples with two elements. Elements can be of Tuple type or primitive tuple type.

impl Zippable<Unit> for Unit

type ZipOutput = Unit

The type of the output generated by zipping two tuples.

type ZipOutput2 = Unit

The type of the output generated by zipping two tuples, but elements are primitive tuples.

fn zip(self, _: Unit) -> Self::ZipOutput

Zip two tuples.

fn zip2(self, _: Unit) -> Self::ZipOutput2

Zip two tuples, but output elements are primitive tuples.

impl Copy for Unit

impl Eq for Unit

impl StructuralPartialEq for Unit

impl TupleLenEqTo<Unit> for Unit