Struct Tuple

Source

pub struct Tuple<First, Other>(pub First, pub Other);

Expand description

The type used to represent tuples containing at least one element.

See Unit type which represents tuples containing no elements.

The TupleLike trait defines the basic methods of all Tuple types and Unit type. Check out TupleLike’s documentation page to see exactly what APIs are available.

§Build a tuple

You can create a tuple quickly and easily using the tuple! macro:

use tuplez::tuple;
let tup = tuple!(1, "hello", 3.14);

Use ; to indicate repeated elements:

use tuplez::tuple;
assert_eq!(tuple!(1.0, 2;3, "3"), tuple!(1.0, 2, 2, 2, "3"));

Remember that macros do not directly evaluate expressions, so:

use tuplez::tuple;

let mut x = 0;
assert_eq!(tuple!({x += 1; x}; 3), tuple!(1, 2, 3));

§Representation

Unlike primitive tuple types, Tuple uses a recursive form of representation:

Primitive tuple representation:
    (T0, T1, T2, T3)
`Tuple` representation:
    Tuple<T0, Tuple<T1, Tuple<T2, Tuple<T3, Unit>>>>

… but don’t worry, in almost all cases Tuple will not take up more memory:

use std::mem::size_of;
use tuplez::{Tuple, Unit};

assert_eq!(size_of::<(i32, f64, &str)>(),
    size_of::<Tuple<i32, Tuple<f64, Tuple<&str, Unit>>>>());

The advantage of using the recursive form of representation is that we can implement a variety of methods on tuples of any length, instead of only implementing these methods on tuples of length less than 12 (or 32).

As a shorthand, we use Tuple<T0, T1, ... Tn> to represent a Tuple type containing N+1 elements in the following text, please keep in mind that this is not a true Tuple representation.

A Tuple can also be used as one of the elements of another Tuple, without restriction.

§Explicit tuple types

In most cases, Tuple or Tuple<_, _> is sufficient to meet the syntax requirements:


use tuplez::Tuple;

let tup = Tuple::from((1, "hello", 3.14)); // or
let tup: Tuple<_, _> = From::from((1, "hello", 3.14));

But sometimes, you may still need to annotate the complete tuple type explicitly. At this point, you can use the tuple_t! macro to generate it:

use tuplez::{tuple, tuple_t};

let tup: tuple_t!(i32, String, f64) = Default::default();
assert_eq!(tup, tuple!(0, String::new(), 0.0));

let unit: tuple_t!() = Default::default();
assert_eq!(unit, tuple!());

fn use_tuple(tup: tuple_t!(i32, &dyn std::fmt::Debug, tuple_t!(String, String))) {
    todo!()
}

Use ; to indicate repeated types:

use tuplez::{tuple, tuple_t};

let tup: tuple_t!(i32, f64;3, i32) = tuple!(1, 2.0, 3.0, 4.0, 5);

Sometimes, you may want to know the exact type of a tuple variable, so that you can call an associated method of this tuple type, such as, Default::default(). However, the signature of this type can be very long and complex, and you may not want to write it out completely via tuple_t!.

Here’s a little trick that might help:

use tuplez::tuple;

fn default_by<T: Default>(_: &T) -> T {
    T::default()
}

let tup = tuple!([1, 2, 3], tuple!("hello".to_string(), 3.14), 8);
let tup2 = default_by(&tup);
assert_eq!(tup2, tuple!([0; 3], tuple!(String::new(), 0.0), 0));

§Element access

There is a get! macro that can be used to get elements, the only restriction is that the index must be an integer literal:

use tuplez::{get, tuple};

let tup = tuple!(1, "hello", 3.14);
assert_eq!(get!(tup; 0), 1);
assert_eq!(get!(tup; 1), "hello");
assert_eq!(get!(tup; 2), 3.14);

This macro will be expanded to standard member access syntax:

get!(tup; 0) => tup.0
get!(tup; 1) => tup.1.0
get!(tup; 2) => tup.1.1.0

… so, here’s an example of modifying elements:

use tuplez::{get, tuple};

fn add_one(x: &mut i32) { *x += 1; }

let mut tup = tuple!(1, "hello", 3.14);
add_one(&mut get!(tup; 0));
assert_eq!(tup, tuple!(2, "hello", 3.14));

§Push, pop, join and split

Any tuple can push further elements, or join another one, with no length limit.

use tuplez::{tuple, TupleLike};

let tup = tuple!();

let tup2 = tup.push(1);             // Push element to back
assert_eq!(tup2, tuple!(1));

let tup3 = tup2.push_back("hello"); // Same as `push`, push element to back
assert_eq!(tup3, tuple!(1, "hello"));

let tup4 = tup3.push_front(3.14);   // Push element to front
assert_eq!(tup4, tuple!(3.14, 1, "hello"));

let tup5 = tup3.join(tup4);         // Join two tuples
assert_eq!(tup5, tuple!(1, "hello", 3.14, 1, "hello"));

Units are not Poppable, and all Tuples are Poppable:

use tuplez::{tuple, TupleLike};

let tup = tuple!(1, "hello", 3.14, [1, 2, 3]);

let (tup2, arr) = tup.pop();        // Pop element from back
assert_eq!(tup2, tuple!(1, "hello", 3.14));
assert_eq!(arr, [1, 2, 3]);

let (tup3, pi) = tup2.pop_back();   // Same as `pop`, pop element from back
assert_eq!(tup3, tuple!(1, "hello"));
assert_eq!(pi, 3.14);

let (tup4, num) = tup3.pop_front();  // Pop element from front
assert_eq!(tup4, tuple!("hello"));
assert_eq!(num, 1);

let (unit, hello) = tup4.pop();
assert_eq!(unit, tuple!());
assert_eq!(hello, "hello");

// _ = unit.pop()                   // Error: cannot pop a `Unit`

The take! macro can take out an element by its index or type:

use tuplez::{take, tuple};

let tup = tuple!(1, "hello", 3.14, [1, 2, 3]);

let (element, remainder) = take!(tup; 2);
assert_eq!(element, 3.14);
assert_eq!(remainder, tuple!(1, "hello", [1, 2, 3]));

let (element, remainder) = take!(tup; &str);
assert_eq!(element, "hello");
assert_eq!(remainder, tuple!(1, 3.14, [1, 2, 3]));

You can use the split_at! macro to split a tuple into two parts. Like the get! macro, the index must be an integer literal:

use tuplez::{split_at, tuple};

let tup = tuple!(1, "hello", 3.14, [1, 2, 3]);

let (left, right) = split_at!(tup; 2);
assert_eq!(left, tuple!(1, "hello"));
assert_eq!(right, tuple!(3.14, [1, 2, 3]));

let (left, right) = split_at!(tup; 0);
assert_eq!(left, tuple!());
assert_eq!(right, tup);

let (left, right) = split_at!(tup; 4);
assert_eq!(left, tup);
assert_eq!(right, tuple!());

§Get subsequences

You can get a subsequence of a tuple via the subseq() method:

use tuplez::{tuple, TupleLike, tuple_t};

let tup = tuple!(12, "hello", 24, 3.14, true);
let subseq: tuple_t!(&str, bool) = tup.subseq();
assert_eq!(subseq, tuple!("hello", true));

// Two candidates available: `(12, true)` or `(24, true)`.
// let subseq: tuple_t!(i32, bool) = tup.subseq();

// No candidates available.
// `(true, "hello")` cannot be a candidate, since its element order is
// different from the supersequence.
// let subseq: tuple_t!(bool, &str) = tup.subseq();

// Although `24` is also `i32`, but only `(12, "hello")` is a candidate.
let subseq: tuple_t!(i32, &str) = tup.subseq();
assert_eq!(subseq, tuple!(12, "hello"));

// It's OK to pick all `i32`s since there is only one candidate.
let subseq: tuple_t!(i32, i32) = tup.subseq();
assert_eq!(subseq, tuple!(12, 24));

You can also get a continuous subsequence via the con_subseq(), it may do somethings that subseq() cannot do:

use tuplez::{tuple, TupleLike, tuple_t};

let tup = tuple!(12, "hello", 24, true, false);

// For `subseq`, 4 candidates available:
//      `(12, true)`,
//      `(12, false)`,
//      `(24, true)`,
//      `(24, false)`,
// so this cannot be compiled.
// let subseq: tuple_t!(i32, bool) = tup.subseq();

// But for `con_subseq`，only `(24, true)` is a candidate.
let subseq: tuple_t!(i32, bool) = tup.con_subseq();
assert_eq!(subseq, tuple!(24, true));

There are also many methods about subsequence: subseq_ref(), subseq_mut(), swap_subseq(), replace_subseq(), con_subseq_ref(), con_subseq_mut(), swap_con_subseq(), replace_con_subseq(). Please refer to their own documentation.

§Trait implementations on `Tuple`

For Tuple<T0, T1, ... Tn>, when all types T0, T1, … Tn implement the Debug / Clone / Copy / PartialEq / Eq / PartialOrd / Ord / Hash / Default / Neg / Not trait(s), then the Tuple<T0, T1, ... Tn> also implements it/them.

For example:

use tuplez::tuple;

let tup = tuple!(false, true, 26u8);            // All elements implement `Not`
assert_eq!(!tup, tuple!(true, false, 229u8));   // So `Tuple` also implements `Not`

For Tuple<T0, T1, ... Tn> and Tuple<U0, U1, ... Un>, when each Ti implements Trait<Ui> if the Trait is Add / AddAssign / Sub / SubAssign / Mul / MulAssign / Div / DivAssign / Rem / RemAssign / BitAnd / BitAndAssign / BitOr / BitOrAssign / BitXor / BitXorAssign / Shl / ShlAssign / Shr / ShrAssign, then Tuple<T0, T1, ... Tn> also implements Trait<Tuple<U0, U1, ... Un>>.

For example:

use tuplez::tuple;

let tup1 = tuple!(5, "hello ".to_string());
let tup2 = tuple!(4, "world");
assert_eq!(tup1 + tup2, tuple!(9, "hello world".to_string()));

If the number of elements on both sides is not equal, then the excess will be retained as is:

use tuplez::tuple;

let x = tuple!(10, "hello".to_string(), 3.14, vec![1, 2]);
let y = tuple!(5, " world");
assert_eq!(x + y, tuple!(15, "hello world".to_string(), 3.14, vec![1, 2]));

§Traverse tuples

You can traverse tuples by foreach().

Call foreach() on a tuple requires a mapper implementing Mapper as the parameter. Check its documentation page for examples.

However, here are two ways you can quickly build a mapper.

§Traverse tuples by element types

The mapper! macro helps you build a mapper that traverses tuples according to their element types.

For example:

use tuplez::{mapper, tuple, TupleLike};

let tup = tuple!(1, "hello", 3.14).foreach(mapper! {
    |x: i32| -> i64 { x as i64 }
    |x: f32| -> String { x.to_string() }
    <'a> |x: &'a str| -> &'a [u8] { x.as_bytes() }
});
assert_eq!(tup, tuple!(1i64, b"hello" as &[u8], "3.14".to_string()));

§Traverse tuples in order of their elements

You can create a new tuple with the same number of elements, whose elements are all callable objects that accepts an element and returns another value (FnOnce(T) -> U), then, you can use that tuple as a mapper.

use tuplez::{tuple, TupleLike};

let tup = tuple!(1, 2, 3);
let result = tup.foreach(
    tuple!(
        |x| x as f32,
        |x: i32| x.to_string(),
        |x: i32| Some(x),
    )
);
assert_eq!(result, tuple!(1.0, "2".to_string(), Some(3)));

§Fold tuples

You can fold tuples by fold().

Call fold() on a tuple requires a folder implementing Folder as the parameter. Check its documentation page for examples.

However, here are two ways you can quickly build a folder.

§Fold tuples by element types

The folder! macro helps you build a folder that folds tuples according to their element types.

For example:

use tuplez::{folder, tuple, TupleLike};

let tup = tuple!(Some(1), "2", Some(3.0));
let result = tup.fold(
    folder! { String; // Type of `acc` of all closures must be the same and annotated at the front
        |acc, x: &str| { acc + &x.to_string() }
        <T: ToString> |acc, x: Option<T>| { acc + &x.unwrap().to_string() }
    },
    String::new(),
);
assert_eq!(result, "123".to_string());

§Fold tuples in order of their elements

You can create a new tuple with the same number of elements, whose elements are all callable objects that accepts the accumulation value and an element and returns new accumulation value (FnOnce(Acc, T) -> Acc), then, you can use that tuple as a folder.

For example:

use tuplez::{tuple, TupleLike};

let tup = tuple!(1, "2", 3.0);
let result = tup.fold(
    tuple!(
        |acc, x| (acc + x) as f64,
        |acc: f64, x: &str| acc.to_string() + x,
        |acc: String, x| acc.parse::<i32>().unwrap() + x as i32,
    ),  // Type of `acc` of each closure is the return type of the previous closure.
    0,
);
assert_eq!(result, 15);

§Convert from/to primitive tuples

Okay, we’re finally talking about the only interfaces of Tuple that limits the maximum number of elements.

Since Rust does not have a way to represent primitive tuple types with an arbitrary number of elements, the interfaces for converting from/to primitive tuple types is only implemented for Tuples with no more than 32 elements.


use tuplez::{ToPrimitive, tuple, Tuple, tuple_t};

let tup = tuple!(1, "hello", 3.14);
let prim_tup = (1, "hello", 3.14);
assert_eq!(tup.primitive(), prim_tup);
assert_eq!(tup, Tuple::from(prim_tup));

let unit = tuple!();
let prim_unit = ();
assert_eq!(unit.primitive(), prim_unit);
assert_eq!(unit, <tuple_t!()>::from(prim_unit));

§Convert from/to primitive arrays

If all elements of a tuple are of the same type, then it can be converted from/to primitive arrays.

Currently tuples cannot be converted from/to primitive arrays with no limit on the number of elements, since the generic constant expressions feature is still unstable yet.

Therefore, by default only tuples with no more than 32 elements are supported to be converted from/to primitive arrays.

However, if you are OK with using rustc released to nightly channel to compile codes with unstable features, you can enable the any_array feature, then tuplez will use unstable features to implement conversion from/to primitive arrays on tuples of any number of elements.

tuplez = { features = [ "any_array" ] }

For examples:

// Enable Rust's `generic_const_exprs` feature if you enable tuplez's `any_array` feature.
#![cfg_attr(feature = "any_array", feature(generic_const_exprs))]

use tuplez::{ToArray, tuple, tuple_t};

assert_eq!(tuple!(1, 2, 3, 4, 5, 6).to_array(), [1, 2, 3, 4, 5, 6]);
assert_eq!(<tuple_t!(i32; 4)>::from([1, 2, 3, 4]), tuple!(1, 2, 3, 4));

// `Unit` can be converted from/to array of any element type
let _ : [i32; 0] = tuple!().to_array();
let _ : [String; 0] = tuple!().to_array();
let _ = <tuple_t!()>::from([3.14; 0]);
let _ = <tuple_t!()>::from([""; 0]);

Tuple Fields§

§0: First

First element.

§1: Other

Other elements. See representation.

Struct TupleCopy item path

§Build a tuple

§Representation

§Explicit tuple types

§Element access

§Push, pop, join and split

§Get subsequences

§Trait implementations on Tuple

§Traverse tuples

§Traverse tuples by element types

§Traverse tuples in order of their elements

§Fold tuples

§Fold tuples by element types

§Fold tuples in order of their elements

§Convert from/to primitive tuples

§Convert from/to primitive arrays

Tuple Fields§

Trait Implementations§

impl<'a, 'b, First1, Other1, First2, Other2> Add<&'a Tuple<First2, Other2>> for &'b Tuple<First1, Other1>where &'b First1: Add<&'a First2>, &'b Other1: Add<&'a Other2>, Other1: TupleLike, Other2: TupleLike,

type Output = Tuple<<&'b First1 as Add<&'a First2>>::Output, <&'b Other1 as Add<&'a Other2>>::Output>

fn add(self, rhs: &'a Tuple<First2, Other2>) -> Self::Output

impl<'a, First1, Other1, First2, Other2> Add<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: Add<&'a First2>, Other1: Add<&'a Other2> + TupleLike, Other2: TupleLike,

type Output = Tuple<<First1 as Add<&'a First2>>::Output, <Other1 as Add<&'a Other2>>::Output>

fn add(self, rhs: &'a Tuple<First2, Other2>) -> Self::Output

impl<First, Other> Add<&Unit> for &Tuple<First, Other>where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<First, Other> Add<&Unit> for Tuple<First, Other>where Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<'a, First1, Other1, First2, Other2> Add<Tuple<First2, Other2>> for &'a Tuple<First1, Other1>where &'a First1: Add<First2>, &'a Other1: Add<Other2>, Other1: TupleLike, Other2: TupleLike,

type Output = Tuple<<&'a First1 as Add<First2>>::Output, <&'a Other1 as Add<Other2>>::Output>

fn add(self, rhs: Tuple<First2, Other2>) -> Self::Output

impl<First1, Other1, First2, Other2> Add<Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: Add<First2>, Other1: Add<Other2> + TupleLike, Other2: TupleLike,

type Output = Tuple<<First1 as Add<First2>>::Output, <Other1 as Add<Other2>>::Output>

fn add(self, rhs: Tuple<First2, Other2>) -> Self::Output

impl<First, Other> Add<Unit> for &Tuple<First, Other>where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<First, Other> Add<Unit> for Tuple<First, Other>where Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<'a, First1, Other1, First2, Other2> AddAssign<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: AddAssign<&'a First2> + TupleLike, Other1: AddAssign<&'a Other2> + TupleLike,

fn add_assign(&mut self, rhs: &'a Tuple<First2, Other2>)

impl<First1, Other1, First2, Other2> AddAssign<Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: AddAssign<First2> + TupleLike, Other1: AddAssign<Other2> + TupleLike,

fn add_assign(&mut self, rhs: Tuple<First2, Other2>)

impl<First, Other> AsDeref for Tuple<First, Other>where First: Deref, Other: AsDeref,

type AsDerefOutput<'a> = Tuple<&'a <First as Deref>::Target, <Other as AsDeref>::AsDerefOutput<'a>> where Self: 'a

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

impl<First, Other> AsDerefMut for Tuple<First, Other>where First: DerefMut, Other: AsDerefMut,

type AsDerefMutOutput<'a> = Tuple<&'a mut <First as Deref>::Target, <Other as AsDerefMut>::AsDerefMutOutput<'a>> where Self: 'a

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

impl<'a, 'b, First1, Other1, First2, Other2> BitAnd<&'a Tuple<First2, Other2>> for &'b Tuple<First1, Other1>where &'b First1: BitAnd<&'a First2>, &'b Other1: BitAnd<&'a Other2>, Other1: TupleLike, Other2: TupleLike,

type Output = Tuple<<&'b First1 as BitAnd<&'a First2>>::Output, <&'b Other1 as BitAnd<&'a Other2>>::Output>

fn bitand(self, rhs: &'a Tuple<First2, Other2>) -> Self::Output

impl<'a, First1, Other1, First2, Other2> BitAnd<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: BitAnd<&'a First2>, Other1: BitAnd<&'a Other2> + TupleLike, Other2: TupleLike,

type Output = Tuple<<First1 as BitAnd<&'a First2>>::Output, <Other1 as BitAnd<&'a Other2>>::Output>

fn bitand(self, rhs: &'a Tuple<First2, Other2>) -> Self::Output

impl<First, Other> BitAnd<&Unit> for &Tuple<First, Other>where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<First, Other> BitAnd<&Unit> for Tuple<First, Other>where Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<'a, First1, Other1, First2, Other2> BitAnd<Tuple<First2, Other2>> for &'a Tuple<First1, Other1>where &'a First1: BitAnd<First2>, &'a Other1: BitAnd<Other2>, Other1: TupleLike, Other2: TupleLike,

type Output = Tuple<<&'a First1 as BitAnd<First2>>::Output, <&'a Other1 as BitAnd<Other2>>::Output>

fn bitand(self, rhs: Tuple<First2, Other2>) -> Self::Output

impl<First1, Other1, First2, Other2> BitAnd<Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: BitAnd<First2>, Other1: BitAnd<Other2> + TupleLike, Other2: TupleLike,

type Output = Tuple<<First1 as BitAnd<First2>>::Output, <Other1 as BitAnd<Other2>>::Output>

fn bitand(self, rhs: Tuple<First2, Other2>) -> Self::Output

impl<First, Other> BitAnd<Unit> for &Tuple<First, Other>where Tuple<First, Other>: Clone, Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<First, Other> BitAnd<Unit> for Tuple<First, Other>where Other: TupleLike,

type Output = Tuple<First, Other>

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

impl<'a, First1, Other1, First2, Other2> BitAndAssign<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: BitAndAssign<&'a First2> + TupleLike, Other1: BitAndAssign<&'a Other2> + TupleLike,

fn bitand_assign(&mut self, rhs: &'a Tuple<First2, Other2>)

impl<First1, Other1, First2, Other2> BitAndAssign<Tuple<First2, Other2>> for Tuple<First1, Other1>where First1: BitAndAssign<First2> + TupleLike, Other1: BitAndAssign<Other2> + TupleLike,

fn bitand_assign(&mut self, rhs: Tuple<First2, Other2>)

Struct Tuple

§Trait implementations on `Tuple`

impl<'a, 'b, First1, Other1, First2, Other2> Add<&'a Tuple<First2, Other2>> for &'b Tuple<First1, Other1>
where &'b First1: Add<&'a First2>, &'b Other1: Add<&'a Other2>, Other1: TupleLike, Other2: TupleLike,

impl<'a, First1, Other1, First2, Other2> Add<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: Add<&'a First2>, Other1: Add<&'a Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> Add<&Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> Add<&Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> Add<Tuple<First2, Other2>> for &'a Tuple<First1, Other1>
where &'a First1: Add<First2>, &'a Other1: Add<Other2>, Other1: TupleLike, Other2: TupleLike,

impl<First1, Other1, First2, Other2> Add<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: Add<First2>, Other1: Add<Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> Add<Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> Add<Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> AddAssign<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: AddAssign<&'a First2> + TupleLike, Other1: AddAssign<&'a Other2> + TupleLike,

impl<First1, Other1, First2, Other2> AddAssign<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: AddAssign<First2> + TupleLike, Other1: AddAssign<Other2> + TupleLike,

impl<First, Other> AsDeref for Tuple<First, Other>
where First: Deref, Other: AsDeref,

impl<First, Other> AsDerefMut for Tuple<First, Other>
where First: DerefMut, Other: AsDerefMut,

impl<'a, 'b, First1, Other1, First2, Other2> BitAnd<&'a Tuple<First2, Other2>> for &'b Tuple<First1, Other1>
where &'b First1: BitAnd<&'a First2>, &'b Other1: BitAnd<&'a Other2>, Other1: TupleLike, Other2: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitAnd<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitAnd<&'a First2>, Other1: BitAnd<&'a Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> BitAnd<&Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> BitAnd<&Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitAnd<Tuple<First2, Other2>> for &'a Tuple<First1, Other1>
where &'a First1: BitAnd<First2>, &'a Other1: BitAnd<Other2>, Other1: TupleLike, Other2: TupleLike,

impl<First1, Other1, First2, Other2> BitAnd<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitAnd<First2>, Other1: BitAnd<Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> BitAnd<Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> BitAnd<Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitAndAssign<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitAndAssign<&'a First2> + TupleLike, Other1: BitAndAssign<&'a Other2> + TupleLike,

impl<First1, Other1, First2, Other2> BitAndAssign<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitAndAssign<First2> + TupleLike, Other1: BitAndAssign<Other2> + TupleLike,

impl<'a, 'b, First1, Other1, First2, Other2> BitOr<&'a Tuple<First2, Other2>> for &'b Tuple<First1, Other1>
where &'b First1: BitOr<&'a First2>, &'b Other1: BitOr<&'a Other2>, Other1: TupleLike, Other2: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitOr<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitOr<&'a First2>, Other1: BitOr<&'a Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> BitOr<&Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> BitOr<&Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitOr<Tuple<First2, Other2>> for &'a Tuple<First1, Other1>
where &'a First1: BitOr<First2>, &'a Other1: BitOr<Other2>, Other1: TupleLike, Other2: TupleLike,

impl<First1, Other1, First2, Other2> BitOr<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitOr<First2>, Other1: BitOr<Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> BitOr<Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> BitOr<Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitOrAssign<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitOrAssign<&'a First2> + TupleLike, Other1: BitOrAssign<&'a Other2> + TupleLike,

impl<First1, Other1, First2, Other2> BitOrAssign<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitOrAssign<First2> + TupleLike, Other1: BitOrAssign<Other2> + TupleLike,

impl<'a, 'b, First1, Other1, First2, Other2> BitXor<&'a Tuple<First2, Other2>> for &'b Tuple<First1, Other1>
where &'b First1: BitXor<&'a First2>, &'b Other1: BitXor<&'a Other2>, Other1: TupleLike, Other2: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitXor<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitXor<&'a First2>, Other1: BitXor<&'a Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> BitXor<&Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> BitXor<&Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitXor<Tuple<First2, Other2>> for &'a Tuple<First1, Other1>
where &'a First1: BitXor<First2>, &'a Other1: BitXor<Other2>, Other1: TupleLike, Other2: TupleLike,

impl<First1, Other1, First2, Other2> BitXor<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitXor<First2>, Other1: BitXor<Other2> + TupleLike, Other2: TupleLike,

impl<First, Other> BitXor<Unit> for &Tuple<First, Other>
where Tuple<First, Other>: Clone, Other: TupleLike,

impl<First, Other> BitXor<Unit> for Tuple<First, Other>
where Other: TupleLike,

impl<'a, First1, Other1, First2, Other2> BitXorAssign<&'a Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitXorAssign<&'a First2> + TupleLike, Other1: BitXorAssign<&'a Other2> + TupleLike,

impl<First1, Other1, First2, Other2> BitXorAssign<Tuple<First2, Other2>> for Tuple<First1, Other1>
where First1: BitXorAssign<First2> + TupleLike, Other1: BitXorAssign<Other2> + TupleLike,

impl<'a, T, R, First, Other> Callable<&'a mut T, PhantomMut> for Tuple<First, Other>
where First: Fn(&mut T) -> R, R: 'a, Other: Callable<&'a mut T, PhantomMut>,

impl<T, R, First, Other> Callable<T, PhantomClone> for Tuple<First, Other>
where T: Clone, First: Fn(T) -> R, Other: Callable<T, PhantomClone>,