shpat 0.1.0

sasha's solution to common patterns
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
62
63
64
65
66
67
68
69
70
71
72
73

//! Unifies the behaviour of types which represent a success or failure
//! dichotomy.
//!
//! The goal is to be able to call unwrap on these these types, and get the
//! underlying success value, or panic the program.
//!
//! This trait is closely tied to the `Try` trait.

use std::fmt::Debug;

/// Unifies the behaviour of types which represent a success or a failure.
pub trait Unwrappable<T>: Sized {
    /// Returns the underlying value, or panics the program if `self` is a
    /// failure.
    fn unwrap(s: Self) -> T;
}

impl<T, E> Unwrappable<T> for Result<T, E>
where
    E: Debug,
{
    fn unwrap(s: Self) -> T {
        Result::unwrap(s)
    }
}

impl<T> Unwrappable<T> for Option<T> {
    fn unwrap(s: Self) -> T {
        Option::unwrap(s)
    }
}

#[cfg(test)]
mod result {
    use super::*;

    #[test]
    fn unwrap_ok_path() {
        let r: Result<_, ()> = Ok(42);
        assert_eq!(Unwrappable::unwrap(r), 42);

        let r: Result<(), ()> = Ok(());
        assert_eq!(Unwrappable::unwrap(r), ());
    }

    #[test]
    #[should_panic]
    fn unwrap_err_path() {
        let r: Result<(), _> = Err(42);
        Unwrappable::unwrap(r);
    }
}

#[cfg(test)]
mod option {
    use super::*;

    #[test]
    fn unwrap_some_path() {
        let o = Some(42);
        assert_eq!(Unwrappable::unwrap(o), 42);

        let o = Some(());
        assert_eq!(Unwrappable::unwrap(o), ());
    }

    #[test]
    #[should_panic]
    fn unwrap_none_path() {
        let o: Option<()> = None;
        Unwrappable::unwrap(o);
    }
}