expect_with 1.0.0

Expect with formatting
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

//! Expect with formatting

#![warn(missing_docs)]

use std::fmt::Debug;

/// Adds `expect_with()`. It is implemented for any `Option<T>` and `Result<T, E>` where `E` is `Debug` (all std types that has `expect` method).
///
/// This method functions exactly the same as `except()` but evaluates error message only when actual error occurres.
///
/// # Example
/// ```rust
/// # use expect_with::ExpectWith;
/// # fn some_heavy_function() -> String {
/// #   return String::from("42");
/// # }
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// #
/// let result: Result<(), String> = Err(String::from("some error"));
/// result.expect_with(|| format!("error {}", some_heavy_function()));
/// #
/// #   Ok(())
/// # }
/// ```
pub trait ExpectWith<T> {
    /// Same as `expect` but evaluates error message only when needed
    #[track_caller]
    fn expect_with<F, S>(self, f: F) -> T
    where
        S: AsRef<str>,
        F: FnOnce() -> S;
}

impl<T, E> ExpectWith<T> for Result<T, E>
where
    E: Debug,
{
    #[inline]
    #[track_caller]
    fn expect_with<F, S>(self, f: F) -> T
    where
        S: AsRef<str>,
        F: FnOnce() -> S,
    {
        match self {
            Ok(t) => t,
            Err(e) => panic!("{}: {:?}", f().as_ref(), e),
        }
    }
}

impl<T> ExpectWith<T> for Option<T> {
    #[inline]
    #[track_caller]
    fn expect_with<F, S>(self, f: F) -> T
    where
        S: AsRef<str>,
        F: FnOnce() -> S,
    {
        match self {
            Some(t) => t,
            None => panic!("{:?}", f().as_ref()),
        }
    }
}