Trait TupleSet 

pub trait TupleSet<T> {
    // Required methods
    fn set(&mut self, value: T) -> Option<T>;
    fn get(&self) -> Option<&T>;
    unsafe fn set_unchecked(&mut self, value: T);
    unsafe fn get_unchecked(&self) -> &T;
    fn map<F, R>(&mut self, f: F) -> Option<R>
       where F: FnOnce(&mut T) -> R;
    unsafe fn map_unchecked<F, R>(&mut self, f: F) -> R
       where F: FnOnce(&mut T) -> R;

    // Provided method
    fn take(&mut self) -> Option<T>
       where T: Default { ... }
}

Trait for setting values in tuples.

Required Methods

fn set(&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(&self) -> Option<&T>

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

unsafe fn set_unchecked(&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 will panic.

Examples

use tuple_set::TupleSet;

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

unsafe fn get_unchecked(&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.

fn map<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);

unsafe fn map_unchecked<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 or appears multiple times will panic.

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 take(&mut self) -> Option<T>

where T: Default,

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<Target: 'static, T1: 'static> TupleSet<Target> for (T1,)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

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

fn set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

impl<Target: 'static, 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<Target> 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 set(&mut self, value: Target) -> Option<Target>

unsafe fn set_unchecked(&mut self, value: Target)

fn get(&self) -> Option<&Target>

unsafe fn get_unchecked(&self) -> &Target

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

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

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

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

Implementors