Primitive Type tuple

A finite heterogeneous sequence, (T, U, ..).

Let’s cover each of those in turn:

Tuples are finite. In other words, a tuple has a length. Here’s a tuple of length 3:

("hello", 5, 'c');

‘Length’ is also sometimes called ‘arity’ here; each tuple of a different length is a different, distinct type.

Tuples are heterogeneous. This means that each element of the tuple can have a different type. In that tuple above, it has the type:

(&'static str, i32, char)

Tuples are a sequence. This means that they can be accessed by position; this is called ‘tuple indexing’, and it looks like this:

let tuple = ("hello", 5, 'c');

assert_eq!(tuple.0, "hello");
assert_eq!(tuple.1, 5);
assert_eq!(tuple.2, 'c');

The sequential nature of the tuple applies to its implementations of various traits. For example, in PartialOrd and Ord, the elements are compared sequentially until the first non-equal set is found.

For more about tuples, see the book.

Trait implementations

In this documentation the shorthand (T₁, T₂, …, Tₙ) is used to represent tuples of varying length. When that is used, any trait bound expressed on T applies to each element of the tuple independently. Note that this is a convenience notation to avoid repetitive documentation, not valid Rust syntax.

Due to a temporary restriction in Rust’s type system, the following traits are only implemented on tuples of arity 12 or less. In the future, this may change:

• PartialEq
• Eq
• PartialOrd
• Ord
• Debug
• Default
• Hash
• From<[T; N]>

The following traits are implemented for tuples of any length. These traits have implementations that are automatically generated by the compiler, so are not limited by missing language features.

• Clone
• Copy
• Send
• Sync
• Unpin
• UnwindSafe
• RefUnwindSafe

Examples

Basic usage:

let tuple = ("hello", 5, 'c');

assert_eq!(tuple.0, "hello");

Tuples are often used as a return type when you want to return more than one value:

fn calculate_point() -> (i32, i32) {
    // Don't do a calculation, that's not the point of the example
    (4, 5)
}

let point = calculate_point();

assert_eq!(point.0, 4);
assert_eq!(point.1, 5);

// Combining this with patterns can be nicer.

let (x, y) = calculate_point();

assert_eq!(x, 4);
assert_eq!(y, 5);

Homogeneous tuples can be created from arrays of appropriate length:

let array: [u32; 3] = [1, 2, 3];
let tuple: (u32, u32, u32) = array.into();

Implementations

impl<T> (T,)

Trait Implementations

impl<A: Debug, Z: Debug, Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (A, Z, Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<B: Debug, A: Debug, Z: Debug, Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<C: Debug, B: Debug, A: Debug, Z: Debug, Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<D: Debug, C: Debug, B: Debug, A: Debug, Z: Debug, Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<E: Debug, D: Debug, C: Debug, B: Debug, A: Debug, Z: Debug, Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (E, D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<T> Debug for (T₁, T₂, …, Tₙ)

where T: ?Sized + Debug,

This trait is implemented for tuples up to twelve items long.

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

Formats the value using the given formatter.

impl<U: Debug, T> Debug for (U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<V: Debug, U: Debug, T> Debug for (V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<W: Debug, V: Debug, U: Debug, T> Debug for (W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<Z: Debug, Y: Debug, X: Debug, W: Debug, V: Debug, U: Debug, T> Debug for (Z, Y, X, W, V, U, T)

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<A: Default, Z: Default, Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (A, Z, Y, X, W, V, U, T)

fn default() -> (A, Z, Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<B: Default, A: Default, Z: Default, Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (B, A, Z, Y, X, W, V, U, T)

fn default() -> (B, A, Z, Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<C: Default, B: Default, A: Default, Z: Default, Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (C, B, A, Z, Y, X, W, V, U, T)

fn default() -> (C, B, A, Z, Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<D: Default, C: Default, B: Default, A: Default, Z: Default, Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (D, C, B, A, Z, Y, X, W, V, U, T)

fn default() -> (D, C, B, A, Z, Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<E: Default, D: Default, C: Default, B: Default, A: Default, Z: Default, Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (E, D, C, B, A, Z, Y, X, W, V, U, T)

fn default() -> (E, D, C, B, A, Z, Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<T: Default> Default for (T₁, T₂, …, Tₙ)

This trait is implemented for tuples up to twelve items long.

fn default() -> (T,)

Returns the “default value” for a type.

impl<U: Default, T: Default> Default for (U, T)

fn default() -> (U, T)

Returns the “default value” for a type.

impl<V: Default, U: Default, T: Default> Default for (V, U, T)

fn default() -> (V, U, T)

Returns the “default value” for a type.

impl<W: Default, V: Default, U: Default, T: Default> Default for (W, V, U, T)

fn default() -> (W, V, U, T)

Returns the “default value” for a type.

impl<X: Default, W: Default, V: Default, U: Default, T: Default> Default for (X, W, V, U, T)

fn default() -> (X, W, V, U, T)

Returns the “default value” for a type.

impl<Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (Y, X, W, V, U, T)

fn default() -> (Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<Z: Default, Y: Default, X: Default, W: Default, V: Default, U: Default, T: Default> Default for (Z, Y, X, W, V, U, T)

fn default() -> (Z, Y, X, W, V, U, T)

Returns the “default value” for a type.

impl<A: Eq, Z: Eq, Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (A, Z, Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<B: Eq, A: Eq, Z: Eq, Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<C: Eq, B: Eq, A: Eq, Z: Eq, Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<D: Eq, C: Eq, B: Eq, A: Eq, Z: Eq, Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<E: Eq, D: Eq, C: Eq, B: Eq, A: Eq, Z: Eq, Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (E, D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<T> Eq for (T₁, T₂, …, Tₙ)

where T: ?Sized + Eq,

This trait is implemented for tuples up to twelve items long.

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<U: Eq, T> Eq for (U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<V: Eq, U: Eq, T> Eq for (V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<W: Eq, V: Eq, U: Eq, T> Eq for (W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<Z: Eq, Y: Eq, X: Eq, W: Eq, V: Eq, U: Eq, T> Eq for (Z, Y, X, W, V, U, T)

where T: ?Sized + Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<A, EA> Extend<(A₁, A₂, …, Aₙ)> for (EA₁, EA₂, …, EAₙ)

where EA: Extend<A>,

This trait is implemented for tuples up to twelve items long. The impls for 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.

fn extend<T: IntoIterator<Item = (A,)>>(&mut self, into_iter: T)

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (A,))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (A,))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<B, A, EB, EA> Extend<(B, A)> for (EB, EA)

where EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (B, A)>>(&mut self, into_iter: T)

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<C, B, A, EC, EB, EA> Extend<(C, B, A)> for (EC, EB, EA)

where EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (C, B, A)>>(&mut self, into_iter: T)

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<D, C, B, A, ED, EC, EB, EA> Extend<(D, C, B, A)> for (ED, EC, EB, EA)

where ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (D, C, B, A)>>(&mut self, into_iter: T)

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<E, D, C, B, A, EE, ED, EC, EB, EA> Extend<(E, D, C, B, A)> for (EE, ED, EC, EB, EA)

where EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (E, D, C, B, A)>>(&mut self, into_iter: T)

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<F, E, D, C, B, A, EF, EE, ED, EC, EB, EA> Extend<(F, E, D, C, B, A)> for (EF, EE, ED, EC, EB, EA)

where EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (F, E, D, C, B, A)>>(&mut self, into_iter: T)

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<G, F, E, D, C, B, A, EG, EF, EE, ED, EC, EB, EA> Extend<(G, F, E, D, C, B, A)> for (EG, EF, EE, ED, EC, EB, EA)

where EG: Extend<G>, EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (G, F, E, D, C, B, A)>>( &mut self, into_iter: T, )

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<H, G, F, E, D, C, B, A, EH, EG, EF, EE, ED, EC, EB, EA> Extend<(H, G, F, E, D, C, B, A)> for (EH, EG, EF, EE, ED, EC, EB, EA)

where EH: Extend<H>, EG: Extend<G>, EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (H, G, F, E, D, C, B, A)>>( &mut self, into_iter: T, )

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<I, H, G, F, E, D, C, B, A, EI, EH, EG, EF, EE, ED, EC, EB, EA> Extend<(I, H, G, F, E, D, C, B, A)> for (EI, EH, EG, EF, EE, ED, EC, EB, EA)

where EI: Extend<I>, EH: Extend<H>, EG: Extend<G>, EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (I, H, G, F, E, D, C, B, A)>>( &mut self, into_iter: T, )

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (I, H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (I, H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<J, I, H, G, F, E, D, C, B, A, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA> Extend<(J, I, H, G, F, E, D, C, B, A)> for (EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)

where EJ: Extend<J>, EI: Extend<I>, EH: Extend<H>, EG: Extend<G>, EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (J, I, H, G, F, E, D, C, B, A)>>( &mut self, into_iter: T, )

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (J, I, H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked(&mut self, item: (J, I, H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<K, J, I, H, G, F, E, D, C, B, A, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA> Extend<(K, J, I, H, G, F, E, D, C, B, A)> for (EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)

where EK: Extend<K>, EJ: Extend<J>, EI: Extend<I>, EH: Extend<H>, EG: Extend<G>, EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (K, J, I, H, G, F, E, D, C, B, A)>>( &mut self, into_iter: T, )

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (K, J, I, H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked( &mut self, item: (K, J, I, H, G, F, E, D, C, B, A), )

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<L, K, J, I, H, G, F, E, D, C, B, A, EL, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA> Extend<(L, K, J, I, H, G, F, E, D, C, B, A)> for (EL, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)

where EL: Extend<L>, EK: Extend<K>, EJ: Extend<J>, EI: Extend<I>, EH: Extend<H>, EG: Extend<G>, EF: Extend<F>, EE: Extend<E>, ED: Extend<D>, EC: Extend<C>, EB: Extend<B>, EA: Extend<A>,

fn extend<T: IntoIterator<Item = (L, K, J, I, H, G, F, E, D, C, B, A)>>( &mut self, into_iter: T, )

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (L, K, J, I, H, G, F, E, D, C, B, A))

🔬This is a nightly-only experimental API. (extend_one #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

Reserves capacity in a collection for the given number of additional elements.

unsafe fn extend_one_unchecked( &mut self, item: (L, K, J, I, H, G, F, E, D, C, B, A), )

🔬This is a nightly-only experimental API. (extend_one_unchecked)

Extends a collection with one element, without checking there is enough capacity for it.

impl<T> From<[T; N]> for (T₁, T₂, …, Tₙ)

This trait is implemented for tuples up to twelve items long.

fn from(array: [T; 1]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)

fn from(array: [T; 10]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)

fn from(array: [T; 11]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)

fn from(array: [T; 12]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 2]> for (T, T)

fn from(array: [T; 2]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 3]> for (T, T, T)

fn from(array: [T; 3]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 4]> for (T, T, T, T)

fn from(array: [T; 4]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 5]> for (T, T, T, T, T)

fn from(array: [T; 5]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 6]> for (T, T, T, T, T, T)

fn from(array: [T; 6]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)

fn from(array: [T; 7]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)

fn from(array: [T; 8]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)

fn from(array: [T; 9]) -> Self

Converts to this type from the input type.

impl<I: Into<IpAddr>> From<(I, u16)> for SocketAddr

fn from(pieces: (I, u16)) -> SocketAddr

Converts a tuple struct (Into<IpAddr>, u16) into a SocketAddr.

This conversion creates a SocketAddr::V4 for an IpAddr::V4 and creates a SocketAddr::V6 for an IpAddr::V6.

u16 is treated as port of the newly created SocketAddr.

impl<T> From<(T₁, T₂, …, Tₙ)> for [T; N]

This trait is implemented for tuples up to twelve items long.

fn from(tuple: (T,)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T)> for [T; 2]

fn from(tuple: (T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T)> for [T; 3]

fn from(tuple: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T)> for [T; 4]

fn from(tuple: (T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T)> for [T; 5]

fn from(tuple: (T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T)> for [T; 6]

fn from(tuple: (T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]

fn from(tuple: (T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]

fn from(tuple: (T, T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]

fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]

fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<A, EA> FromIterator<(EA₁, EA₂, …, EAₙ)> for (A₁, A₂, …, Aₙ)

where A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

This trait is implemented for tuples up to twelve items long. The impls for 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.

fn from_iter<Iter: IntoIterator<Item = (EA,)>>(iter: Iter) -> Self

Creates a value from an iterator.

impl<B, A, EB, EA> FromIterator<(EB, EA)> for (B, A)

where B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EB, EA)>>(iter: Iter) -> Self

Creates a value from an iterator.

impl<C, B, A, EC, EB, EA> FromIterator<(EC, EB, EA)> for (C, B, A)

where C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EC, EB, EA)>>(iter: Iter) -> Self

Creates a value from an iterator.

impl<D, C, B, A, ED, EC, EB, EA> FromIterator<(ED, EC, EB, EA)> for (D, C, B, A)

where D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (ED, EC, EB, EA)>>(iter: Iter) -> Self

Creates a value from an iterator.

impl<E, D, C, B, A, EE, ED, EC, EB, EA> FromIterator<(EE, ED, EC, EB, EA)> for (E, D, C, B, A)

where E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<F, E, D, C, B, A, EF, EE, ED, EC, EB, EA> FromIterator<(EF, EE, ED, EC, EB, EA)> for (F, E, D, C, B, A)

where F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<G, F, E, D, C, B, A, EG, EF, EE, ED, EC, EB, EA> FromIterator<(EG, EF, EE, ED, EC, EB, EA)> for (G, F, E, D, C, B, A)

where G: Default + Extend<EG>, F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EG, EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<H, G, F, E, D, C, B, A, EH, EG, EF, EE, ED, EC, EB, EA> FromIterator<(EH, EG, EF, EE, ED, EC, EB, EA)> for (H, G, F, E, D, C, B, A)

where H: Default + Extend<EH>, G: Default + Extend<EG>, F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EH, EG, EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<I, H, G, F, E, D, C, B, A, EI, EH, EG, EF, EE, ED, EC, EB, EA> FromIterator<(EI, EH, EG, EF, EE, ED, EC, EB, EA)> for (I, H, G, F, E, D, C, B, A)

where I: Default + Extend<EI>, H: Default + Extend<EH>, G: Default + Extend<EG>, F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EI, EH, EG, EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<J, I, H, G, F, E, D, C, B, A, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA> FromIterator<(EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)> for (J, I, H, G, F, E, D, C, B, A)

where J: Default + Extend<EJ>, I: Default + Extend<EI>, H: Default + Extend<EH>, G: Default + Extend<EG>, F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<K, J, I, H, G, F, E, D, C, B, A, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA> FromIterator<(EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)> for (K, J, I, H, G, F, E, D, C, B, A)

where K: Default + Extend<EK>, J: Default + Extend<EJ>, I: Default + Extend<EI>, H: Default + Extend<EH>, G: Default + Extend<EG>, F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<L, K, J, I, H, G, F, E, D, C, B, A, EL, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA> FromIterator<(EL, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)> for (L, K, J, I, H, G, F, E, D, C, B, A)

where L: Default + Extend<EL>, K: Default + Extend<EK>, J: Default + Extend<EJ>, I: Default + Extend<EI>, H: Default + Extend<EH>, G: Default + Extend<EG>, F: Default + Extend<EF>, E: Default + Extend<EE>, D: Default + Extend<ED>, C: Default + Extend<EC>, B: Default + Extend<EB>, A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

fn from_iter<Iter: IntoIterator<Item = (EL, EK, EJ, EI, EH, EG, EF, EE, ED, EC, EB, EA)>>( iter: Iter, ) -> Self

Creates a value from an iterator.

impl<T> Hash for (T₁, T₂, …, Tₙ)

where T: ?Sized + Hash,

This trait is implemented for tuples up to twelve items long.

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B> Hash for (T, B)

where B: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C> Hash for (T, B, C)

where C: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D> Hash for (T, B, C, D)

where D: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E> Hash for (T, B, C, D, E)

where E: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F> Hash for (T, B, C, D, E, F)

where F: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G> Hash for (T, B, C, D, E, F, G)

where G: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H> Hash for (T, B, C, D, E, F, G, H)

where H: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I> Hash for (T, B, C, D, E, F, G, H, I)

where I: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J> Hash for (T, B, C, D, E, F, G, H, I, J)

where J: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K> Hash for (T, B, C, D, E, F, G, H, I, J, K)

where K: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash, L> Hash for (T, B, C, D, E, F, G, H, I, J, K, L)

where L: ?Sized + Hash,

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoBounds<T> for (Bound<T>, Bound<T>)

fn into_bounds(self) -> (Bound<T>, Bound<T>)

🔬This is a nightly-only experimental API. (range_into_bounds #136903)

Convert this range into the start and end bounds. Returns (start_bound, end_bound).

fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)

where Self: Sized, T: Ord, R: Sized + IntoBounds<T>,

🔬This is a nightly-only experimental API. (range_into_bounds #136903)

Compute the intersection of self and other.

impl<A: Ord, Z: Ord, Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (A, Z, Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(A, Z, Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<B: Ord, A: Ord, Z: Ord, Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<C: Ord, B: Ord, A: Ord, Z: Ord, Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<D: Ord, C: Ord, B: Ord, A: Ord, Z: Ord, Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<E: Ord, D: Ord, C: Ord, B: Ord, A: Ord, Z: Ord, Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (E, D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<T> Ord for (T₁, T₂, …, Tₙ)

where T: ?Sized + Ord,

This trait is implemented for tuples up to twelve items long.

fn cmp(&self, other: &(T,)) -> 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,

Restrict a value to a certain interval.

impl<U: Ord, T> Ord for (U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(U, T)) -> 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,

Restrict a value to a certain interval.

impl<V: Ord, U: Ord, T> Ord for (V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<W: Ord, V: Ord, U: Ord, T> Ord for (W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<Z: Ord, Y: Ord, X: Ord, W: Ord, V: Ord, U: Ord, T> Ord for (Z, Y, X, W, V, U, T)

where T: ?Sized + Ord,

fn cmp(&self, other: &(Z, Y, X, W, V, U, T)) -> 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,

Restrict a value to a certain interval.

impl<A: PartialEq, Z: PartialEq, Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(A, Z, Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(A, Z, Y, X, W, V, U, T)) -> bool

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

impl<B: PartialEq, A: PartialEq, Z: PartialEq, Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> bool

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

impl<C: PartialEq, B: PartialEq, A: PartialEq, Z: PartialEq, Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

impl<D: PartialEq, C: PartialEq, B: PartialEq, A: PartialEq, Z: PartialEq, Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

impl<E: PartialEq, D: PartialEq, C: PartialEq, B: PartialEq, A: PartialEq, Z: PartialEq, Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (E, D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

impl<T> PartialEq for (T₁, T₂, …, Tₙ)

where T: ?Sized + PartialEq,

This trait is implemented for tuples up to twelve items long.

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<U: PartialEq, T> PartialEq for (U, T)

where T: ?Sized + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<V: PartialEq, U: PartialEq, T> PartialEq for (V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(V, U, T)) -> bool

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

impl<W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(W, V, U, T)) -> bool

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

impl<X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(X, W, V, U, T)) -> bool

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

impl<Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(Y, X, W, V, U, T)) -> bool

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

impl<Z: PartialEq, Y: PartialEq, X: PartialEq, W: PartialEq, V: PartialEq, U: PartialEq, T> PartialEq for (Z, Y, X, W, V, U, T)

where T: ?Sized + PartialEq,

fn eq(&self, other: &(Z, Y, X, W, V, U, T)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &(Z, Y, X, W, V, U, T)) -> bool

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

impl<A: PartialOrd, Z: PartialOrd, Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(A, Z, Y, X, W, V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(A, Z, Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(A, Z, Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(A, Z, Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(A, Z, Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(A, Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(A, Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(A, Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(A, Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<B: PartialOrd, A: PartialOrd, Z: PartialOrd, Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(B, A, Z, Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt( &self, other: &(B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le( &self, other: &(B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt( &self, other: &(B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge( &self, other: &(B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<C: PartialOrd, B: PartialOrd, A: PartialOrd, Z: PartialOrd, Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp( &self, other: &(C, B, A, Z, Y, X, W, V, U, T), ) -> Option<Ordering>

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

fn lt(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt( &self, other: &(C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le( &self, other: &(C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt( &self, other: &(C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge( &self, other: &(C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<D: PartialOrd, C: PartialOrd, B: PartialOrd, A: PartialOrd, Z: PartialOrd, Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp( &self, other: &(D, C, B, A, Z, Y, X, W, V, U, T), ) -> Option<Ordering>

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

fn lt(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt( &self, other: &(D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le( &self, other: &(D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt( &self, other: &(D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge( &self, other: &(D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<E: PartialOrd, D: PartialOrd, C: PartialOrd, B: PartialOrd, A: PartialOrd, Z: PartialOrd, Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (E, D, C, B, A, Z, Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp( &self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T), ) -> Option<Ordering>

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

fn lt(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt( &self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le( &self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt( &self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge( &self, other: &(E, D, C, B, A, Z, Y, X, W, V, U, T), ) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<T> PartialOrd for (T₁, T₂, …, Tₙ)

where T: ?Sized + PartialOrd,

This trait is implemented for tuples up to twelve items long.

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

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

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

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(T,)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(T,)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(T,)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(T,)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<U: PartialOrd, T> PartialOrd for (U, T)

where T: ?Sized + PartialOrd,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

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

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

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<V: PartialOrd, U: PartialOrd, T> PartialOrd for (V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(V, U, T)) -> bool

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

fn ge(&self, other: &(V, U, T)) -> bool

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

fn gt(&self, other: &(V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(W, V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(W, V, U, T)) -> bool

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

fn ge(&self, other: &(W, V, U, T)) -> bool

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

fn gt(&self, other: &(W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(X, W, V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(Y, X, W, V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<Z: PartialOrd, Y: PartialOrd, X: PartialOrd, W: PartialOrd, V: PartialOrd, U: PartialOrd, T> PartialOrd for (Z, Y, X, W, V, U, T)

where T: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &(Z, Y, X, W, V, U, T)) -> Option<Ordering>

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

fn lt(&self, other: &(Z, Y, X, W, V, U, T)) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &(Z, Y, X, W, V, U, T)) -> bool

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

fn ge(&self, other: &(Z, Y, X, W, V, U, T)) -> bool

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

fn gt(&self, other: &(Z, Y, X, W, V, U, T)) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn __chaining_lt(&self, other: &(Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

fn __chaining_le(&self, other: &(Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

fn __chaining_gt(&self, other: &(Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

fn __chaining_ge(&self, other: &(Z, Y, X, W, V, U, T)) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl<'a, T: ?Sized + 'a> RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>)

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: ?Sized + PartialOrd<T>,

Returns true if item is contained in the range.

fn is_empty(&self) -> bool

where T: PartialOrd,

🔬This is a nightly-only experimental API. (range_bounds_is_empty #137300)

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl<T> RangeBounds<T> for (Bound<T>, Bound<T>)

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: ?Sized + PartialOrd<T>,

Returns true if item is contained in the range.

fn is_empty(&self) -> bool

where T: PartialOrd,

🔬This is a nightly-only experimental API. (range_bounds_is_empty #137300)

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl<T> SliceIndex<[T]> for (Bound<usize>, Bound<usize>)

type Output = [T]

The output type returned by methods.

fn get(self, slice: &[T]) -> Option<&Self::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, slice: &mut [T]) -> Option<&mut Self::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked(self, slice: *const [T]) -> *const Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a pointer to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable pointer to the output at this location, without performing any bounds checking.

fn index(self, slice: &[T]) -> &Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, slice: &mut [T]) -> &mut Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl SliceIndex<ByteStr> for (Bound<usize>, Bound<usize>)

type Output = ByteStr

The output type returned by methods.

fn get(self, slice: &ByteStr) -> Option<&Self::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, slice: &mut ByteStr) -> Option<&mut Self::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked(self, slice: *const ByteStr) -> *const Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a pointer to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut(self, slice: *mut ByteStr) -> *mut Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable pointer to the output at this location, without performing any bounds checking.

fn index(self, slice: &ByteStr) -> &Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, slice: &mut ByteStr) -> &mut Self::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl SliceIndex<str> for (Bound<usize>, Bound<usize>)

Implements substring slicing for arbitrary bounds.

Returns a slice of the given string bounded by the byte indices provided by each bound.

This operation is O(1).

Panics

Panics if begin or end (if it exists and once adjusted for inclusion/exclusion) does not point to the starting byte offset of a character (as defined by is_char_boundary), if begin > end, or if end > len.

type Output = str

The output type returned by methods.

fn get(self, slice: &str) -> Option<&str>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, slice: &mut str) -> Option<&mut str>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked(self, slice: *const str) -> *const str

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a pointer to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut str

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable pointer to the output at this location, without performing any bounds checking.

fn index(self, slice: &str) -> &str

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, slice: &mut str) -> &mut str

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl<A: ConstParamTy_, Z: ConstParamTy_, Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (A, Z, Y, X, W, V, U, T)

impl<B: ConstParamTy_, A: ConstParamTy_, Z: ConstParamTy_, Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (B, A, Z, Y, X, W, V, U, T)

impl<C: ConstParamTy_, B: ConstParamTy_, A: ConstParamTy_, Z: ConstParamTy_, Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (C, B, A, Z, Y, X, W, V, U, T)

impl<D: ConstParamTy_, C: ConstParamTy_, B: ConstParamTy_, A: ConstParamTy_, Z: ConstParamTy_, Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (D, C, B, A, Z, Y, X, W, V, U, T)

impl<E: ConstParamTy_, D: ConstParamTy_, C: ConstParamTy_, B: ConstParamTy_, A: ConstParamTy_, Z: ConstParamTy_, Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (E, D, C, B, A, Z, Y, X, W, V, U, T)

impl<T: ConstParamTy_> ConstParamTy_ for (T₁, T₂, …, Tₙ)

This trait is implemented for tuples up to twelve items long.

impl<U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (U, T)

impl<V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (V, U, T)

impl<W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (W, V, U, T)

impl<X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (X, W, V, U, T)

impl<Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (Y, X, W, V, U, T)

impl<Z: ConstParamTy_, Y: ConstParamTy_, X: ConstParamTy_, W: ConstParamTy_, V: ConstParamTy_, U: ConstParamTy_, T: ConstParamTy_> ConstParamTy_ for (Z, Y, X, W, V, U, T)

impl Sealed for (Bound<usize>, Bound<usize>)

impl<A, Z, Y, X, W, V, U, T> StructuralPartialEq for (A, Z, Y, X, W, V, U, T)

impl<B, A, Z, Y, X, W, V, U, T> StructuralPartialEq for (B, A, Z, Y, X, W, V, U, T)

impl<C, B, A, Z, Y, X, W, V, U, T> StructuralPartialEq for (C, B, A, Z, Y, X, W, V, U, T)

impl<D, C, B, A, Z, Y, X, W, V, U, T> StructuralPartialEq for (D, C, B, A, Z, Y, X, W, V, U, T)

impl<E, D, C, B, A, Z, Y, X, W, V, U, T> StructuralPartialEq for (E, D, C, B, A, Z, Y, X, W, V, U, T)

impl<T> StructuralPartialEq for (T₁, T₂, …, Tₙ)

This trait is implemented for tuples up to twelve items long.

impl<U, T> StructuralPartialEq for (U, T)

impl<V, U, T> StructuralPartialEq for (V, U, T)

impl<W, V, U, T> StructuralPartialEq for (W, V, U, T)

impl<X, W, V, U, T> StructuralPartialEq for (X, W, V, U, T)

impl<Y, X, W, V, U, T> StructuralPartialEq for (Y, X, W, V, U, T)

impl<Z, Y, X, W, V, U, T> StructuralPartialEq for (Z, Y, X, W, V, U, T)

impl<A: UnsizedConstParamTy, Z: UnsizedConstParamTy, Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (A, Z, Y, X, W, V, U, T)

impl<B: UnsizedConstParamTy, A: UnsizedConstParamTy, Z: UnsizedConstParamTy, Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (B, A, Z, Y, X, W, V, U, T)

impl<C: UnsizedConstParamTy, B: UnsizedConstParamTy, A: UnsizedConstParamTy, Z: UnsizedConstParamTy, Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (C, B, A, Z, Y, X, W, V, U, T)

impl<D: UnsizedConstParamTy, C: UnsizedConstParamTy, B: UnsizedConstParamTy, A: UnsizedConstParamTy, Z: UnsizedConstParamTy, Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (D, C, B, A, Z, Y, X, W, V, U, T)

impl<E: UnsizedConstParamTy, D: UnsizedConstParamTy, C: UnsizedConstParamTy, B: UnsizedConstParamTy, A: UnsizedConstParamTy, Z: UnsizedConstParamTy, Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (E, D, C, B, A, Z, Y, X, W, V, U, T)

impl<T: UnsizedConstParamTy> UnsizedConstParamTy for (T₁, T₂, …, Tₙ)

This trait is implemented for tuples up to twelve items long.

impl<U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (U, T)

impl<V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (V, U, T)

impl<W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (W, V, U, T)

impl<X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (X, W, V, U, T)

impl<Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (Y, X, W, V, U, T)

impl<Z: UnsizedConstParamTy, Y: UnsizedConstParamTy, X: UnsizedConstParamTy, W: UnsizedConstParamTy, V: UnsizedConstParamTy, U: UnsizedConstParamTy, T: UnsizedConstParamTy> UnsizedConstParamTy for (Z, Y, X, W, V, U, T)