option_trait 1.0.7

Helper traits for more generalized options
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::{ops::MaybeAndThen, NotVoid, PureMaybe};

pub trait MaybeAnd<T, Rhs>: MaybeAndThen<T, T, Rhs>
where
    T: ?Sized,
    Rhs: PureMaybe<T> + ?Sized
{
    type Output: PureMaybe<T> + ?Sized = <Self as MaybeAndThen<T, T, Rhs>>::Output;

    fn and(self, other: Rhs) -> <Self as MaybeAnd<T, Rhs>>::Output
    where
        <Self as MaybeAnd<T, Rhs>>::Output: Sized,
        Self: Sized,
        Rhs: Sized;
}

impl<Lhs, Rhs, T> MaybeAnd<T, Rhs> for Lhs
where
    T: ?Sized,
    Lhs: PureMaybe<T> + ?Sized,
    Rhs: PureMaybe<T> + ?Sized
{
    default fn and(self, _: Rhs) -> <Self as MaybeAnd<T, Rhs>>::Output
    where
        <Self as MaybeAnd<T, Rhs>>::Output: Sized,
        Self: Sized,
        Rhs: Sized
    {
        unreachable!()
    }
}

impl<T> MaybeAnd<T, Option<T>> for Option<T>
{
    fn and(self, rhs: Option<T>) -> <Self as MaybeAnd<T, Option<T>>>::Output
    where
        <Self as MaybeAnd<T, Option<T>>>::Output: Sized
    {
        self.and(rhs)
    }
}
impl<T> MaybeAnd<T, ()> for Option<T>
where
    T: NotVoid
{
    fn and(self, (): ()) -> <Self as MaybeAnd<T, ()>>::Output
    {
        
    }
}
impl<T> MaybeAnd<T, T> for Option<T>
{
    fn and(self, rhs: T) -> <Self as MaybeAnd<T, T>>::Output
    {
        self.map(|_| rhs)
    }
}

impl<Rhs, T> MaybeAnd<T, Rhs> for ()
where
    T: ?Sized + NotVoid,
    Rhs: PureMaybe<T>
{
    fn and(self, _: Rhs) -> <Self as MaybeAnd<T, Rhs>>::Output
    where
        <Self as MaybeAnd<T, Rhs>>::Output: Sized
    {
        
    }
}

impl<T> MaybeAnd<T, Option<T>> for T
{
    fn and(self, other: Option<T>) -> <Self as MaybeAnd<T, Option<T>>>::Output
    where
        <Self as MaybeAnd<T, Option<T>>>::Output: Sized
    {
        other
    }
}
impl<T> MaybeAnd<T, ()> for T
where
    T: NotVoid + ?Sized
{
    fn and(self, (): ()) -> <Self as MaybeAnd<T, ()>>::Output
    where
        Self: Sized,
        <Self as MaybeAnd<T, ()>>::Output: Sized
    {
        
    }
}
impl<T> MaybeAnd<T, T> for T
where
    T: ?Sized
{
    fn and(self, rhs: T) -> <Self as MaybeAnd<T, T>>::Output
    where
        <Self as MaybeAnd<T, T>>::Output: Sized
    {
        rhs
    }
}