Trait TupleSet 

pub trait TupleSet {
    // Required methods
    fn count<T: 'static>(&self) -> usize;
    unsafe fn get_unchecked<T: 'static>(&self) -> &T;
    unsafe fn map_unchecked<T: 'static, F, R>(&mut self, f: F) -> R
       where F: FnOnce(&mut T) -> R;

    // Provided methods
    fn contains_unique<T: 'static>(&self) -> bool { ... }
    fn set<T: 'static>(&mut self, value: T) -> Option<T> { ... }
    fn get<T: 'static>(&self) -> Option<&T> { ... }
    unsafe fn set_unchecked<T: 'static>(&mut self, value: T) { ... }
    fn map<T: 'static, F, R>(&mut self, f: F) -> Option<R>
       where F: FnOnce(&mut T) -> R { ... }
    fn take<T: 'static + Default>(&mut self) -> Option<T> { ... }
}

Trait for accessing and manipulating tuple elements by type.

Required Methods

fn count<T: 'static>(&self) -> usize

Returns the number of times type T appears in the tuple.

unsafe fn get_unchecked<T: 'static>(&self) -> &T

Get a reference to the value for type T in the tuple without checking.

Safety

The caller must ensure that T appears exactly once in the tuple. Calling this with a type that doesn’t exist will panic, while calling this with a type that appears multiple times will return a reference to the first occurrence.

unsafe fn map_unchecked<T: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Applies a mapping function to the value of type T in the tuple without checking.

Safety

The caller must ensure that T appears exactly once in the tuple. Calling this with a type that doesn’t exist will panic, while calling this with a type that appears multiple times may lead to solely changing the first occurrence.

Examples

use tuple_set::TupleSet;

let mut tuple = (42i32, "hello", 3.14f64);
let old = unsafe {
    tuple.map_unchecked(|x: &mut i32| {
        let old = *x;
        *x *= 2;
        old
    })
};
assert_eq!(old, 42);
assert_eq!(tuple.0, 84);

Provided Methods

fn contains_unique<T: 'static>(&self) -> bool

Returns true if the tuple contains exactly one instance of type T.

fn set<T: 'static>(&mut self, value: T) -> Option<T>

Sets the value for type T if it appears exactly once in the tuple.

Returns None on success, Some(value) if the type is not found or appears multiple times.

Examples

use tuple_set::TupleSet;

let mut tuple = (42i32, "hello", 3.14f64);
assert!(tuple.set(100i32).is_none());
assert_eq!(tuple.0, 100);

// Type not found
let result = tuple.set(true);
assert_eq!(result, Some(true));

fn get<T: 'static>(&self) -> Option<&T>

Get a reference to the value for type T in the tuple if it appears exactly once.

Returns Some(&T) on success, or None if the type is not found or appears multiple times.

Examples

use tuple_set::TupleSet;

let tuple = (42i32, "hello", 3.14f64);

let value: Option<&i32> = tuple.get();
assert_eq!(value, Some(&42i32));

unsafe fn set_unchecked<T: 'static>(&mut self, value: T)

Sets the value for type T in the tuple without checking.

Safety

The caller must ensure that T appears exactly once in the tuple. Calling this with a type that doesn’t exist or appears multiple times may lead to respectively to a panic or changing solely the first occurrence.

Examples

use tuple_set::TupleSet;

let mut tuple = (42i32, "hello", 3.14f64);
unsafe {
    tuple.set_unchecked(200i32);
}
assert_eq!(tuple.0, 200);

fn map<T: 'static, F, R>(&mut self, f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

Applies a mapping function to the value of type T in the tuple.

Returns Some(result) with the function’s return value on success, or None if the type is not found or appears multiple times.

Examples

use tuple_set::TupleSet;

let mut tuple = (42i32, "hello", 3.14f64);
let old = tuple
    .map(|x: &mut i32| {
        let old = *x;
        *x *= 2;
        old
    })
    .unwrap();
assert_eq!(old, 42);
assert_eq!(tuple.0, 84);

fn take<T: 'static + Default>(&mut self) -> Option<T>

Takes the value out of a T field, leaving T::default() in its place.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl TupleSet for ()

fn count<Target: 'static>(&self) -> usize

Always returns 0 since the tuple is empty.

Examples

use tuple_set::TupleSet;

let tuple = ();
assert_eq!(tuple.count::<i32>(), 0);

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

Always panics since the tuple is empty.

Safety

Calling this function is undefined behavior since the tuple is empty.

Examples

use tuple_set::TupleSet;

let tuple = ();
unsafe {
    let _value: &i32 = tuple.get_unchecked();
}

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, _f: F) -> R

where F: FnOnce(&mut Target) -> R,

Always panics since the tuple is empty.

Safety

Calling this function is undefined behavior since the tuple is empty.

Examples

use tuple_set::TupleSet;

let mut tuple = ();
unsafe {
    tuple.map_unchecked(|x: &mut i32| {
        *x = 42;
    });
}

impl<T1: 'static> TupleSet for (T1,)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static> TupleSet for (T1, T2)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static> TupleSet for (T1, T2, T3)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static> TupleSet for (T1, T2, T3, T4)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static> TupleSet for (T1, T2, T3, T4, T5)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static> TupleSet for (T1, T2, T3, T4, T5, T6)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static, T59: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static, T59: 'static, T60: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static, T59: 'static, T60: 'static, T61: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static, T59: 'static, T60: 'static, T61: 'static, T62: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static, T59: 'static, T60: 'static, T61: 'static, T62: 'static, T63: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static, T13: 'static, T14: 'static, T15: 'static, T16: 'static, T17: 'static, T18: 'static, T19: 'static, T20: 'static, T21: 'static, T22: 'static, T23: 'static, T24: 'static, T25: 'static, T26: 'static, T27: 'static, T28: 'static, T29: 'static, T30: 'static, T31: 'static, T32: 'static, T33: 'static, T34: 'static, T35: 'static, T36: 'static, T37: 'static, T38: 'static, T39: 'static, T40: 'static, T41: 'static, T42: 'static, T43: 'static, T44: 'static, T45: 'static, T46: 'static, T47: 'static, T48: 'static, T49: 'static, T50: 'static, T51: 'static, T52: 'static, T53: 'static, T54: 'static, T55: 'static, T56: 'static, T57: 'static, T58: 'static, T59: 'static, T60: 'static, T61: 'static, T62: 'static, T63: 'static, T64: 'static> TupleSet for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

fn count<Target: 'static>(&self) -> usize

unsafe fn get_unchecked<Target: 'static>(&self) -> &Target

unsafe fn map_unchecked<Target: 'static, F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Target) -> R,

Implementors