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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

/// The `SomeErr` trait provides a method for converting an `Option` into a `Result` by treating `Some` values as `Err` and `None` values as `Ok`.
///
/// # Examples
///
/// ```
/// use some_to_err::SomeToErr;
///
/// let some: Option<&str> = Some("Error");
/// let result = some.some_to_err(42);
/// assert_eq!(result, Err("Error"));
/// ```
///
/// ```
/// use some_to_err::SomeToErr;
///
/// let none: Option<&str> = None;
/// let result = none.some_to_err(42);
/// assert_eq!(result, Ok(42));
/// ```
pub trait SomeToErr {
    type Err;
    fn some_to_err<OK>(self, ok: OK) -> Result<OK, Self::Err>;
}
impl<T> SomeToErr for Option<T> {
    type Err = T;
    fn some_to_err<OK>(self, ok: OK) -> Result<OK, Self::Err> {
        match self {
            Some(err) => Err(err),
            None => Ok(ok),
        }
    }
}

#[cfg(test)]
mod some_to_err_tests {
    use super::SomeToErr;

    #[test]
    fn test_some_err_some() {
        let some: Option<&str> = Some("Error");
        let result = some.some_to_err(42);
        assert_eq!(result, Err("Error"));
    }

    #[test]
    fn test_some_err_none() {
        let none: Option<&str> = None;
        let result = none.some_to_err(42);
        assert_eq!(result, Ok(42));
    }

    #[test]
    fn test_some_err_some_different_type() {
        let some: Option<i32> = Some(123);
        let result = some.some_to_err("Success");
        assert_eq!(result, Err(123));
    }

    #[test]
    fn test_some_err_none_different_type() {
        let none: Option<i32> = None;
        let result = none.some_to_err("Success");
        assert_eq!(result, Ok("Success"));
    }
}

/// The `SomeToErrElse` trait provides a convenient method to convert an `Option<T>` into a `Result<OK, T>`
/// by supplying a closure that generates the `OK` value for the `Result` when the input is `None`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// use some_to_err::SomeToErrElse;
///
/// let input: Option<&str> = None;
/// let result = input.some_to_err_else(|| "OK");
/// assert_eq!(result, Ok("OK"));
/// ```
///
/// ```
/// use some_to_err::SomeToErrElse;
///
/// let input = Some("Error");
/// let result = input.some_to_err_else(|| "OK");
/// assert_eq!(result, Err("Error"));
/// ```
pub trait SomeToErrElse {
    type Err;
    fn some_to_err_else<OK>(self, ok: impl FnOnce() -> OK) -> Result<OK, Self::Err>;
}
impl<T> SomeToErrElse for Option<T> {
    type Err = T;
    fn some_to_err_else<OK>(self, ok: impl FnOnce() -> OK) -> Result<OK, Self::Err> {
        match self {
            Some(err) => Err(err),
            None => Ok(ok()),
        }
    }
}

#[cfg(test)]
mod some_to_err_else_tests {
    use super::SomeToErrElse;

    #[test]
    fn test_some_to_err_with_some() {
        let input = Some("Error");
        let result = input.some_to_err_else(|| "OK");
        assert_eq!(result, Err("Error"));
    }

    #[test]
    fn test_some_to_err_with_none() {
        let input: Option<&str> = None;
        let result = input.some_to_err_else(|| "OK");
        assert_eq!(result, Ok("OK"));
    }

    #[test]
    fn test_some_to_err_with_some_and_closure() {
        let input = Some(2);
        let result = input.some_to_err_else(|| 3 * 3);
        assert_eq!(result, Err(2));
    }

    #[test]
    fn test_some_to_err_with_none_and_closure() {
        let input: Option<i32> = None;
        let result = input.some_to_err_else(|| 3 * 3);
        assert_eq!(result, Ok(9));
    }
}