possible 0.1.0

Rust library providing a three state enum for differentiating between an explicit null value and the absense of a value.
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

use super::Possible;

impl<T, E> Possible<Result<T, E>> {
    /// Transposes an `Possible` of a [`Result`] into a [`Result`] of an `Possible`.
    ///
    /// [`Possible::Void`] will be mapped to [`Ok`]`(`[`Possible::Void`]`)`.
    /// [`Possible::None`] will be mapped to [`Ok`]`(`[`Possible::None`]`)`.
    /// [`Some`]`(`[`Ok`]`(_))` and [`Some`]`(`[`Err`]`(_))` will be mapped to
    /// [`Ok`]`(`[`Some`]`(_))` and [`Err`]`(_)`.
    ///
    /// # Examples
    ///
    /// ```
    /// use possible::Possible;
    ///
    /// #[derive(Debug, Eq, PartialEq)]
    /// struct SomeErr;
    ///
    /// let x: Result<Possible<i32>, SomeErr> = Ok(Possible::Some(5));
    /// let y: Possible<Result<i32, SomeErr>> = Possible::Some(Ok(5));
    /// assert_eq!(x, y.transpose());
    /// ```
    #[inline]
    pub fn transpose(self) -> Result<Possible<T>, E> {
        match self {
            Possible::Some(Err(e)) => Err(e),
            Possible::Some(Ok(x)) => Ok(Possible::Some(x)),
            Possible::None => Ok(Possible::None),
            Possible::Void => Ok(Possible::Void),
        }
    }
}