Enum optional::OptionBool

pub enum OptionBool {
    SomeTrue,
    SomeFalse,
    None,
}

The OptionBool type, a space-efficient Option replacement

Variants

SomeTrue

Some(true)

SomeFalse

Some(false)

None

None

Methods

impl OptionBool

fn some(b: bool) -> Self

Create a SomeTrue for true, SomeFalse for false

fn none() -> Self

Create a None value.

# Examples

 assert_eq!(OptionBool::none(), optional::OptionBool::None);

fn is_some(&self) -> bool

Returns true if the option is a Some value.

# Examples

 assert!(OptionBool::SomeTrue.is_some());
 assert!(OptionBool::SomeFalse.is_some());
 assert!(!OptionBool::None.is_some());

fn is_none(&self) -> bool

Returns true if the option is a Some value.

# Examples

 assert!(!OptionBool::SomeTrue.is_none());
 assert!(!OptionBool::SomeFalse.is_none());
 assert!(OptionBool::None.is_none());

fn expect(&self, msg: &str) -> bool

Unwraps the contained bool, panics on None with given message.

# Panics

if self is None

# Examples

For SomeTrue/SomeFalse, the corresponding bool is returned.

 assert!(OptionBool::SomeTrue.expect("FAIL"));
 assert!(!OptionBool::SomeFalse.expect("FAIL"));

On None, it panics with the given message.

 OptionBool::None.expect("FAIL"); // panics with FAIL

fn unwrap(&self) -> bool

Unwraps the contained bool, panics on None.

# Panics

if self is None

# Examples

For SomeTrue/SomeFalse, the corresponding bool is returned.

 assert!(OptionBool::SomeTrue.unwrap());
 assert!(!OptionBool::SomeFalse.unwrap());

On None, it panics with "unwrap called on None"

 OptionBool::None.unwrap(); // panics

fn unwrap_or(&self, def: bool) -> bool

Returns the contained bool or a default.

# Examples

 assert!(OptionBool::SomeTrue.unwrap_or(false));
 assert!(!OptionBool::SomeFalse.unwrap_or(true));
 assert!(OptionBool::None.unwrap_or(true));
 assert!(!OptionBool::None.unwrap_or(false));

fn unwrap_or_else<F>(self, f: F) -> bool where
    F: FnOnce() -> bool, 

Returns the contained bool or a computed default.

# Examples

 assert!(OptionBool::SomeTrue.unwrap_or_else(|| false));
 assert!(!OptionBool::SomeFalse.unwrap_or_else(|| panic!()));
 assert!(OptionBool::None.unwrap_or_else(|| true));

fn map<U, F>(self, f: F) -> Option<U> where
    F: FnOnce(bool) -> U, 

Maps an OptionBool to an Option<U> by applying the function over the contained bool.

Note that there is also map_bool(..) which works similarly, but returns another OptionBool.

# Examples

Convert the contained bool to a Yes/No message

 assert_eq!(Some("Yes"), OptionBool::SomeTrue.map(
     |b| if b { "Yes" } else { "No" }));

fn map_bool<F>(self, f: F) -> OptionBool where
    F: FnOnce(bool) -> bool, 

Maps an OptionBool to another OptionBool by applying the function over the contained bool.

Note that there is also map(..) which works similarly, but returns an Option<bool>.

# Examples

Invert the contained bool

 assert_eq!(OptionBool::SomeTrue,
     OptionBool::SomeFalse.map_bool(|b| !b));

fn map_or<U, F>(self, default: U, f: F) -> U where
    F: FnOnce(bool) -> U, 

Maps a value to a U by applying the function or return a default U.

# Examples

Map to a string (as per the daily wtf's boolean definition):

 assert_eq!("True", OptionBool::SomeTrue.map_or("FileNotFound",
     |b| if b { "True" } else { "False" }));

fn map_or_else<U, D, F>(self, default: D, f: F) -> U where
    D: FnOnce() -> U,
    F: FnOnce(bool) -> U, 

Maps a value to a U by applying the function or return a computed default.

# Examples

 assert_eq!("True", OptionBool::SomeTrue.map_or_else(|| "FileNotFound",
     |b| if b { "True" } else { "False" }));

fn ok_or<E>(self, err: E) -> Result<bool, E>

Transforms the OptionBool into a Result<bool, E>, mapping SomeX to Ok(X) and None to Err(err).

# Examples

 assert_eq!(OptionBool::SomeTrue.ok_or("Ouch"), Ok(true));
 assert_eq!(OptionBool::None.ok_or("Ouch"), Err("Ouch"));

fn ok_or_else<E, F>(self, err: F) -> Result<bool, E> where
    F: FnOnce() -> E, 

Transforms the OptionBool into a Result<bool, E>, mapping SomeX to Ok(X) and None to a calculated Err(err).

# Examples

 assert_eq!(OptionBool::SomeTrue.ok_or_else(|| something_expensive()), Ok(true));
 assert_eq!(OptionBool::None.ok_or_else(|| "Ouch"), Err("Ouch"));

fn and<U>(self, optb: Option<U>) -> Option<U>

Returns None if the option is None, otherwise returns optb.

# Examples

 assert_eq!(Some(1), OptionBool::SomeTrue.and(Some(1)));
 assert_eq!(None, OptionBool::None.and(Some(1)));
 let actual : Option<u8> = None;
 assert_eq!(None, OptionBool::SomeTrue.and(actual));

fn and_bool(self, optb: OptionBool) -> OptionBool

Returns None if the option is None, otherwise returns optb.

# Examples

 assert_eq!(OptionBool::SomeTrue,
     OptionBool::SomeFalse.and_bool(OptionBool::SomeTrue));
 assert_eq!(OptionBool::None,
     OptionBool::None.and_bool(OptionBool::SomeFalse));
 assert_eq!(OptionBool::None,
     OptionBool::SomeTrue.and_bool(OptionBool::None));

fn and_then<U, F>(self, f: F) -> Option<U> where
    F: FnOnce(bool) -> Option<U>, 

returns None if the OptionBool is None, otherwise calls f with the boolean value and returns the result as an Option<U>

Note that there is also and_then_bool(..) which works similarly, but returns another OptionBool.

# Examples

 assert_eq!(None, OptionBool::SomeFalse.and_then(
     |x| if x { Some(true) } else { None }));

fn and_then_bool<F>(self, f: F) -> OptionBool where
    F: FnOnce(bool) -> OptionBool, 

returns None if the OptionBool is None, otherwise calls f with the boolean value and returns the result as an OptionBool

Note that there is also and_then(..) which works similarly, but returns an Option<bool>.

# Examples

 assert_eq!(OptionBool::None, OptionBool::SomeFalse.and_then_bool(
     |x| if x { OptionBool::SomeTrue } else { OptionBool::None }));

fn or(self, optb: Option<bool>) -> Option<bool>

Returns this as Option unless this is None, in which case returns optb.

# Examples

 assert_eq!(Some(false), OptionBool::SomeFalse.or(Some(true)));
 assert_eq!(Some(true), OptionBool::None.or(Some(true)));
 assert_eq!(None, OptionBool::None.or(None));

fn or_bool(self, optb: OptionBool) -> OptionBool

Returns this as Option unless this is None, in which case returns optb.

# Examples

 assert_eq!(OptionBool::SomeFalse,
     OptionBool::SomeFalse.or_bool(OptionBool::SomeTrue));
 assert_eq!(OptionBool::SomeTrue,
     OptionBool::None.or_bool(OptionBool::SomeTrue));
 assert_eq!(OptionBool::None,
     OptionBool::None.or_bool(OptionBool::None));

fn or_else<F>(self, f: F) -> Option<bool> where
    F: FnOnce() -> Option<bool>, 

Returns this as Option unless this is None, in which case use the supplied function to calculate the result.

Note that there is also or_else_bool(..) which works similarly, but returns another OptionBool.

# Examples

 assert_eq!(Some(false), OptionBool::SomeFalse.or_else(|| Some(true)));
 assert_eq!(Some(true), OptionBool::None.or_else(|| Some(true)));
 assert_eq!(None, OptionBool::None.or_else(|| None));

fn or_else_bool<F>(self, f: F) -> OptionBool where
    F: FnOnce() -> OptionBool, 

Returns this as Option unless this is None, in which case use the supplied function to calculate the result.

Note that there is also or_else(..) which works similarly, but returns an Option<bool>.

# Examples

 assert_eq!(OptionBool::SomeFalse,
     OptionBool::SomeFalse.or_else_bool(|| OptionBool::SomeTrue));
 assert_eq!(OptionBool::SomeTrue,
     OptionBool::None.or_else_bool(|| OptionBool::SomeTrue));
 assert_eq!(OptionBool::None,
     OptionBool::None.or_else_bool(|| OptionBool::None));

fn iter(&self) -> Iter<bool>

return an iterator over all contained (that is zero or one) values.

# Examples

 assert_eq!(None, OptionBool::None.iter().next());
 assert_eq!(Some(&true), OptionBool::SomeTrue.iter().next());

fn as_slice(self) -> &'static [bool]

return a possibly empty slice with the contained value, if any.

# Examples

 assert_eq!(&[true], OptionBool::SomeTrue.as_slice());
 assert!(OptionBool::None.as_slice().is_empty());

fn take(&mut self) -> Option<bool>

Takes the value out of the OptionBool and returns ist as Option<bool>, changing self to None.

Note that there is also take_bool(..) which works similarly, but returns an OptionBool.

# Examples

 let mut x = OptionBool::some(true);
 assert_eq!(Some(true), x.take());
 assert_eq!(OptionBool::None, x);

fn take_bool(&mut self) -> OptionBool

Takes the value out of the OptionBool, changing self to None.

Note that there is also take(..) which works similarly, but returns an Option<bool>.

# Examples

 let mut x = OptionBool::some(true);
 assert_eq!(OptionBool::some(true), x.take_bool());
 assert_eq!(OptionBool::None, x);

Methods from Deref<Target = Option<bool>>

fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

fn as_ref(&self) -> Option<&T>

Converts from Option<T> to Option<&T>.

Examples

Convert an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let num_as_str: Option<String> = Some("10".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `num_as_str` on the stack.
let num_as_int: Option<usize> = num_as_str.as_ref().map(|n| n.len());
println!("still can print num_as_str: {:?}", num_as_str);

fn expect(self, msg: &str) -> T

Unwraps an option, yielding the content of a Some.

Panics

Panics if the value is a None with a custom panic message provided by msg.

Examples

let x = Some("value");
assert_eq!(x.expect("the world is ending"), "value");

let x: Option<&str> = None;
x.expect("the world is ending"); // panics with `the world is ending`

fn unwrap(self) -> T

Moves the value v out of the Option<T> if it is Some(v).

In general, because this function may panic, its use is discouraged. Instead, prefer to use pattern matching and handle the None case explicitly.

Panics

Panics if the self value equals None.

Examples

let x = Some("air");
assert_eq!(x.unwrap(), "air");

let x: Option<&str> = None;
assert_eq!(x.unwrap(), "air"); // fails

fn unwrap_or(self, def: T) -> T

Returns the contained value or a default.

Examples

assert_eq!(Some("car").unwrap_or("bike"), "car");
assert_eq!(None.unwrap_or("bike"), "bike");

fn unwrap_or_else<F>(self, f: F) -> T where
    F: FnOnce() -> T, 

Returns the contained value or computes it from a closure.

Examples

let k = 10;
assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);
assert_eq!(None.unwrap_or_else(|| 2 * k), 20);

fn map<U, F>(self, f: F) -> Option<U> where
    F: FnOnce(T) -> U, 

Maps an Option<T> to Option<U> by applying a function to a contained value.

Examples

Convert an Option<String> into an Option<usize>, consuming the original:

let maybe_some_string = Some(String::from("Hello, World!"));
// `Option::map` takes self *by value*, consuming `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|s| s.len());

assert_eq!(maybe_some_len, Some(13));

fn map_or<U, F>(self, default: U, f: F) -> U where
    F: FnOnce(T) -> U, 

Applies a function to the contained value (if any), or returns a default (if not).

Examples

let x = Some("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);

let x: Option<&str> = None;
assert_eq!(x.map_or(42, |v| v.len()), 42);

fn map_or_else<U, D, F>(self, default: D, f: F) -> U where
    D: FnOnce() -> U,
    F: FnOnce(T) -> U, 

Applies a function to the contained value (if any), or computes a default (if not).

Examples

let k = 21;

let x = Some("foo");
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);

let x: Option<&str> = None;
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);

fn ok_or<E>(self, err: E) -> Result<T, E>

Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(err).

Examples

let x = Some("foo");
assert_eq!(x.ok_or(0), Ok("foo"));

let x: Option<&str> = None;
assert_eq!(x.ok_or(0), Err(0));

fn ok_or_else<E, F>(self, err: F) -> Result<T, E> where
    F: FnOnce() -> E, 

Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(err()).

Examples

let x = Some("foo");
assert_eq!(x.ok_or_else(|| 0), Ok("foo"));

let x: Option<&str> = None;
assert_eq!(x.ok_or_else(|| 0), Err(0));

fn iter(&self) -> Iter<T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

fn and<U>(self, optb: Option<U>) -> Option<U>

Returns None if the option is None, otherwise returns optb.

Examples

let x = Some(2);
let y: Option<&str> = None;
assert_eq!(x.and(y), None);

let x: Option<u32> = None;
let y = Some("foo");
assert_eq!(x.and(y), None);

let x = Some(2);
let y = Some("foo");
assert_eq!(x.and(y), Some("foo"));

let x: Option<u32> = None;
let y: Option<&str> = None;
assert_eq!(x.and(y), None);

fn and_then<U, F>(self, f: F) -> Option<U> where
    F: FnOnce(T) -> Option<U>, 

Returns None if the option is None, otherwise calls f with the wrapped value and returns the result.

Some languages call this operation flatmap.

Examples

fn sq(x: u32) -> Option<u32> { Some(x * x) }
fn nope(_: u32) -> Option<u32> { None }

assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));
assert_eq!(Some(2).and_then(sq).and_then(nope), None);
assert_eq!(Some(2).and_then(nope).and_then(sq), None);
assert_eq!(None.and_then(sq).and_then(sq), None);

fn or(self, optb: Option<T>) -> Option<T>

Returns the option if it contains a value, otherwise returns optb.

Examples

let x = Some(2);
let y = None;
assert_eq!(x.or(y), Some(2));

let x = None;
let y = Some(100);
assert_eq!(x.or(y), Some(100));

let x = Some(2);
let y = Some(100);
assert_eq!(x.or(y), Some(2));

let x: Option<u32> = None;
let y = None;
assert_eq!(x.or(y), None);

fn or_else<F>(self, f: F) -> Option<T> where
    F: FnOnce() -> Option<T>, 

Returns the option if it contains a value, otherwise calls f and returns the result.

Examples

fn nobody() -> Option<&'static str> { None }
fn vikings() -> Option<&'static str> { Some("vikings") }

assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians"));
assert_eq!(None.or_else(vikings), Some("vikings"));
assert_eq!(None.or_else(nobody), None);

fn cloned(self) -> Option<T>

Maps an Option<&T> to an Option<T> by cloning the contents of the option.

Examples

let x = 12;
let opt_x = Some(&x);
assert_eq!(opt_x, Some(&12));
let cloned = opt_x.cloned();
assert_eq!(cloned, Some(12));

fn unwrap_or_default(self) -> T

Returns the contained value or a default

Consumes the self argument then, if Some, returns the contained value, otherwise if None, returns the default value for that type.

Examples

Convert a string to an integer, turning poorly-formed strings into 0 (the default value for integers). parse converts a string to any other type that implements FromStr, returning None on error.

let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().ok().unwrap_or_default();
let bad_year = bad_year_from_input.parse().ok().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);

Trait Implementations

impl Copy for OptionBool

impl Clone for OptionBool

fn clone(&self) -> OptionBool

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for OptionBool

fn eq(&self, __arg_0: &OptionBool) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for OptionBool

impl Ord for OptionBool

fn cmp(&self, __arg_0: &OptionBool) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (ord_max_min)

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (ord_max_min)

Compares and returns the minimum of two values.

impl Hash for OptionBool

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Deref for OptionBool

We can deref-coerce to Option<bool>

type Target = Option<bool>

The resulting type after dereferencing.

fn deref(&self) -> &'static Option<bool>

Dereferences the value.

impl<'a> PartialEq<OptionBool> for &'a OptionBool

fn eq(&self, other: &OptionBool) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Index<RangeFull> for OptionBool

Index for RangeFull (to slice)

type Output = [bool]

The returned type after indexing.

fn index<'a>(&'a self, _: RangeFull) -> &'static [bool]

Performs the indexing (container[index]) operation.

impl PartialOrd for OptionBool

Some(true) > Some(false) > None

fn partial_cmp(&self, other: &OptionBool) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Debug for OptionBool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl IntoIterator for OptionBool

IntoIterator works as expected

# Examples

 let mut pass : bool = false;
 for b in OptionBool::SomeTrue { pass = b; }
 assert!(pass);

 for b in OptionBool::None { assert!(false); }

type Item = bool

The type of the elements being iterated over.

type IntoIter = IterBool

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterBool

Creates an iterator from a value.

impl Default for OptionBool

OptionBool defaults to None.

fn default() -> OptionBool

Returns the "default value" for a type.

impl From<Option<bool>> for OptionBool

fn from(o: Option<bool>) -> Self

Performs the conversion.

impl<'a> From<&'a Option<bool>> for OptionBool

fn from(o: &'a Option<bool>) -> Self

Performs the conversion.