either-both 1.0.0

An enum similar to the well-known `Either`, but with a `Both` variant
Documentation 
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

use super::*;
use either::Either as Other;
impl<L, R> From<Other<L, R>> for Either<L, R> {
    /// Converts the `Either` variant from the `either` crate to this crate's `Either`.
    /// This will either produce the variant `Left` or `Right`, but never `Both`.
    ///
    /// # Example
    ///
    /// ```rust
    /// let left: either::Either<_, ()> = either::Left(());
    /// let right: either::Either<(), _> = either::Right(());
    /// assert!(matches!(left.into(), either_both::Left(_)));
    /// assert!(matches!(right.into(), either_both::Right(_)));
    /// ```
    fn from(value: Other<L, R>) -> Self {
        match value {
            Other::Left(l) => Self::Left(l),
            Other::Right(r) => Self::Right(r),
        }
    }
}

impl<L, R> From<Other<Other<L, R>, (L, R)>> for Either<L, R> {
    fn from(value: Other<Other<L, R>, (L, R)>) -> Self {
        match value {
            Other::Left(Other::Left(l)) => Self::Left(l),
            Other::Left(Other::Right(r)) => Self::Right(r),
            Other::Right((l, r)) => Self::Both(l, r),
        }
    }
}

impl<L, R> From<Other<(L, R), Other<L, R>>> for Either<L, R> {
    fn from(value: Other<(L, R), Other<L, R>>) -> Self {
        match value {
            Other::Left((l, r)) => Self::Both(l, r),
            Other::Right(Other::Left(l)) => Self::Left(l),
            Other::Right(Other::Right(r)) => Self::Right(r),
        }
    }
}

impl<L, R> From<Either<L, R>> for Other<Other<L, R>, (L, R)> {
    fn from(value: Either<L, R>) -> Self {
        match value {
            Either::Left(l) => Self::Left(Other::Left(l)),
            Either::Right(r) => Self::Left(Other::Right(r)),
            Either::Both(l, r) => Self::Right((l, r)),
        }
    }
}

impl<L, R> From<Either<L, R>> for Other<(L, R), Other<L, R>> {
    fn from(value: Either<L, R>) -> Self {
        match value {
            Either::Left(l) => Self::Right(Other::Left(l)),
            Either::Right(r) => Self::Right(Other::Right(r)),
            Either::Both(l, r) => Self::Left((l, r)),
        }
    }
}