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
//! This library provides two convenient traits that allow you to convert values into `Option` or `Result` //! based on the provided predicate. It is somewhat similar to the boolinator crate, except you don't //! need to create a boolean - the predicate will do it for you. This can be useful e.g. when writing a //! long chain that ends with a fold which you want to convert into `Option` or `Result`. //! //! ``` //! use intoif::IntoOption; //! //! fn fizz_buzz(n: u32) -> String { //! [(3, "Fizz"), (5, "Buzz")] //! .iter() //! .filter_map(|(x, s)| if n % x == 0 { Some(*s) } else { None }) //! .collect::<String>() //! .none_if(String::is_empty) //! .unwrap_or_else(|| n.to_string()) //! } //! ``` #![no_std] /// Allow construction of `Option` from any type using predicate to choose between `Some` and `None`. pub trait IntoOption where Self: Sized { /// Returns `Some(self)` if predicate returns true on self, `None` otherwise. fn some_if<P>(self, predicate: P) -> Option<Self> where P: FnOnce(&Self) -> bool { if predicate(&self) { Some(self) } else { None } } /// Returns `None` if predicate returns true on self, `Some(self)` otherwise. fn none_if<P>(self, predicate: P) -> Option<Self> where P: FnOnce(&Self) -> bool { if predicate(&self) { None } else { Some(self) } } } /// Allow construction of `Result` from any type using predicate to choose between `Ok` and `Err`. pub trait IntoResult where Self: Sized { /// Returns `Ok(self)` if predicate returns true on self, `Err(error)` otherwise. fn ok_if<P, E>(self, predicate: P, error: E) -> Result<Self, E> where P: FnOnce(&Self) -> bool { if predicate(&self) { Ok(self) } else { Err(error) } } /// Returns `Ok(self)` if predicate returns true on self, `Err(error)` otherwise. This is /// a lazy version of [ok_if](IntoResult::ok_if), error is constructed only when the predicate fails. fn ok_if_else<P, E, F>(self, predicate: P, error: F) -> Result<Self, E> where P: FnOnce(&Self) -> bool, F: FnOnce() -> E { if predicate(&self) { Ok(self) } else { Err(error()) } } /// Returns `Err(error)` if predicate returns true on self, `Ok(self)` otherwise. fn err_if<P, E>(self, predicate: P, error: E) -> Result<Self, E> where P: FnOnce(&Self) -> bool { if predicate(&self) { Err(error) } else { Ok(self) } } /// Returns `Err(error)` if predicate returns true on self, `Ok(self)` otherwise. This is /// a lazy version of [err_if](IntoResult::err_if), error is constructed only when the predicate succeeds. fn err_if_else<P, E, F>(self, predicate: P, error: F) -> Result<Self, E> where P: FnOnce(&Self) -> bool, F: FnOnce() -> E { if predicate(&self) { Err(error()) } else { Ok(self) } } } impl<T> IntoOption for T {} impl<T> IntoResult for T {}