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
33
34
35
36

use super::Possible;

impl<T> Possible<T> {
    /// Zips `self` with another `Possible`.
    ///
    /// If `self` and `other` are both `Possible::Some`, returns `Possible::Some((s, o))`.
    /// If one of `self` or `other` are `Possible::None`, returns `Possible::None`.
    /// Otherwise, `Possible::Void` or  is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use possible::Possible;
    ///
    /// let x = Possible::Some(1);
    /// let y = Possible::Some("hi");
    /// let z = Possible::None::<u8>;
    /// let w = Possible::Void::<&str>;
    ///
    /// assert_eq!(x.zip(y), Possible::Some((1, "hi")));
    /// assert_eq!(x.zip(z), Possible::None);
    /// assert_eq!(y.zip(w), Possible::Void);
    /// assert_eq!(w.zip(y), Possible::Void);
    /// ```
    pub fn zip<U>(self, other: Possible<U>) -> Possible<(T, U)> {
        match (self, other) {
            (Possible::Some(a), Possible::Some(b)) => Possible::Some((a, b)),

            (Possible::Some(_), Possible::None)
            | (Possible::None, Possible::Some(_))
            | (Possible::None, Possible::None) => Possible::None,

            _ => Possible::Void,
        }
    }
}