ttools - [no description]


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use crate::{Pick, Tupl};

pub trait OptionOfTuple<T: Tupl> {
    fn on<const N: usize>(self) -> Option<T::At>
    where
        T: Pick<N>;
}

impl<T: Tupl> OptionOfTuple<T> for Option<T> {
    fn on<const N: usize>(self) -> Option<<T>::At>
    where
        T: Pick<N>,
    {
        self.map(T::pick)
    }
}
macro_rules! option_of_ref_to_tuple {
    ($name1:ident, $name2:ident, $as_ref:ident, $AsRef:ident $(, $mut:tt)?) => {
        pub trait $name1<'a, T: Tupl> {
            fn on<const N: usize>(
                self,
            ) -> Option<<T::$AsRef<'a> as Pick<N>>::At>
            where
                T::$AsRef<'a>: Pick<N>;
        }
        impl<'a, T: Tupl> $name1<'a, T> for Option<&'a $($mut)? T> {
            fn on<const N: usize>(
                self,
            ) -> Option<<T::$AsRef<'a> as Pick<N>>::At>
            where
                T::$AsRef<'a>: Pick<N>,
            {
                match self {
                    Some(x) => Some(x.$as_ref().pick()),
                    None => None,
                }
            }
        }
        impl<'a, T: Tupl> $name1<'a, T> for &'a $($mut)? Option< T> {
            fn on<const N: usize>(
                self,
            ) -> Option<<T::$AsRef<'a> as Pick<N>>::At>
            where
                T::$AsRef<'a>: Pick<N>,
            {
                match self {
                    Some(x) => Some(x.$as_ref().pick()),
                    None => None,
                }
            }
        }
    };
}

option_of_ref_to_tuple!(
    OptionOfRefToTuple,
    OptionOfRefToTupleWithF,
    as_ref,
    AsRef
);

option_of_ref_to_tuple!(
    OptionOfMutRefToTuple,
    OptionOfMutRefToTupleWithF,
    as_mut,
    AsMut,
    mut
);
#[test]
fn x() {
    struct Y;
    let x = Some(&mut (Y, 2));
    let x = x.on::<1>();
    let x = &mut Some((Y, 2));
    let x = x.on::<1>();
}