Trait bool_ext::BoolExt

source · 
pub trait BoolExt {

Show 24 methods    // Required methods
    fn to_option(self) -> Option<()>;
    fn some<T>(self, some: T) -> Option<T>;
    fn some_with<F: FnOnce() -> T, T>(self, some: F) -> Option<T>;
    fn to_result(self) -> Result<(), ()>;
    fn and_ok<T>(self, ok: T) -> Result<T, ()>;
    fn and_ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>;
    fn or_ok<T>(self, ok: T) -> Result<T, ()>;
    fn or_ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>;
    fn and_err<E>(self, err: E) -> Result<(), E>;
    fn and_err_with<F: FnOnce() -> E, E>(self, err: F) -> Result<(), E>;
    fn or_err<E>(self, err: E) -> Result<(), E>;
    fn or_err_with<F: FnOnce() -> E, E>(self, err: F) -> Result<(), E>;
    fn ok_or_err<T, E>(self, err: E, ok: T) -> Result<T, E>;
    fn ok_or_err_with<F: FnOnce() -> T, G: FnOnce() -> E, T, E>(
        self,
        err: G,
        ok: F
    ) -> Result<T, E>;
    fn map<T>(self, f: T, t: T) -> T;
    fn map_or<F: FnOnce() -> T, T>(self, f: T, t: F) -> T;
    fn map_or_default<F: FnOnce() -> T, T: Default>(self, t: F) -> T;
    fn map_or_else<F: FnOnce() -> T, G: FnOnce() -> T, T>(self, f: G, t: F) -> T;
    fn and_do<F: FnOnce()>(self, t: F) -> bool;
    fn or_do<F: FnOnce()>(self, f: F) -> bool;
    fn and_try_do<F: FnOnce() -> Result<(), E>, E>(
        self,
        t: F
    ) -> Result<bool, E>;
    fn or_try_do<F: FnOnce() -> Result<(), E>, E>(self, f: F) -> Result<bool, E>;
    fn expect(self, msg: &str);
    fn expect_false(self, msg: &str);

}
Expand description

BoolExt trait defines and implements a complete set of Boolean functional combinators.

Required Methods§

source

fn to_option(self) -> Option<()>

§Boolean to Option (bool => Option<T>) adapters
§Transforms true => Some(()), false => None
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).to_option() == Some(()));
use assert2::assert;
use bool_ext::BoolExt;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).to_option() == None);
source

fn some<T>(self, some: T) -> Option<T>

§Transforms true => Some(T), false => None
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).some(Foo) == Some(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).some(Foo) == None);
source

fn some_with<F: FnOnce() -> T, T>(self, some: F) -> Option<T>

§Transforms true => Some(T), false => None, lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...expensive computation
    Foo
}

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).some_with(|| expensive_computation()) == Some(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...some expensive computation
    Foo
}

let vec = vec![1, 2, 3];

// elide `expensive_computation()`
assert!(vec.contains(&4).some_with(|| expensive_computation()) == None);
source

fn to_result(self) -> Result<(), ()>

bool => Result<T, E>

§Transforms true => Ok(()), false => Err(())
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).to_result() == Ok(()));
use assert2::assert;
use bool_ext::BoolExt;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).to_result() == Err(()));
source

fn and_ok<T>(self, ok: T) -> Result<T, ()>

§Transforms true => Ok(T), false => Err(())
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).and_ok(Foo) == Ok(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).and_ok(Foo) == Err(()));
source

fn and_ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>

§Transforms true => Ok(T), false => Err(()), lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...expensive computation
    Foo
}

let vec = Vec::<i32>::new();

assert!(vec.is_empty().and_ok_with(|| expensive_computation()) == Ok(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...some expensive computation
    Foo
}

let vec = vec![1, 2, 3];

// elide `expensive_computation()`
assert!(vec.is_empty().and_ok_with(|| expensive_computation()) == Err(()));
source

fn or_ok<T>(self, ok: T) -> Result<T, ()>

§Transforms true => Err(()), false => Ok(T)
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).or_ok(Foo) == Ok(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).or_ok(Foo) == Err(()));
source

fn or_ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>

§Transforms true => Err(()), false => Ok(T), lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let event_list = vec![1, 2, 3];

assert!(event_list.contains(&2).or_ok(Foo) == Err(()));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...some expensive computation
    Foo
}

let event_list = vec![1, 2, 3];

// elide `expensive_computation()`
assert!(event_list.contains(&4).or_ok_with(|| expensive_computation()) == Ok(Foo));
source

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

§Transforms true => Err(E), false => Ok(())
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).and_err(Foo) == Err(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).and_err(Foo) == Ok(()));
source

fn and_err_with<F: FnOnce() -> E, E>(self, err: F) -> Result<(), E>

§Transforms true => Err(E), false => Ok(()), lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...expensive computation
    Foo
}

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).and_err_with(|| expensive_computation()) == Err(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...some expensive computation
    Foo
}

let vec = vec![1, 2, 3];

// elide `expensive_computation()`
assert!(vec.contains(&4).and_err_with(|| expensive_computation()) == Ok(()));
source

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

§Transforms true => Ok(()), false => Err(E)
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let event_list = vec![1, 2, 3];

assert!(event_list.contains(&2).or_err(Foo) == Ok(()));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

let event_list = vec![1, 2, 3];

assert!(event_list.contains(&4).or_err(Foo) == Err(Foo));
source

fn or_err_with<F: FnOnce() -> E, E>(self, err: F) -> Result<(), E>

§Transforms true => Ok(()), false => Err(E), lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...expensive computation
    Foo
}

let event_list = vec![1, 2, 3];

assert!(event_list.contains(&2).or_err_with(|| expensive_computation()) == Ok(()));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_computation() -> Foo {
    // ...some expensive computation
    Foo
}

let vec = vec![1, 2, 3];

// elide `expensive_computation()`
assert!(vec.contains(&4).or_err_with(|| expensive_computation()) == Err(Foo));
source

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

§Transforms true => Ok(T), false => Err(E), lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

#[derive(Debug, PartialEq)]
struct Foo;

#[derive(Debug, PartialEq)]
struct Error;

impl std::error::Error for Error {}

impl std::fmt::Display for Error {
    fn fmt(&self,f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "BoolExt Example Error")
    }
}

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).ok_or_err(Error, Foo) == Ok(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

#[derive(Debug, PartialEq)]
struct Error;

impl std::fmt::Display for Error {
    fn fmt(&self,f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "BoolExt Example Error")
    }
}

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).ok_or_err(Error, Foo) == Err(Error));
source

fn ok_or_err_with<F: FnOnce() -> T, G: FnOnce() -> E, T, E>( self, err: G, ok: F ) -> Result<T, E>

§Transforms true => Ok(T), false => Err(E), lazily evaluated
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_ok_computation() -> Foo {
    // ...expensive computation
    Foo
}

#[derive(Debug, PartialEq)]
struct Bar;

fn expensive_err_computation() -> Bar {
    // ...expensive computation
    Bar
}

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).ok_or_err_with(
    || expensive_err_computation(),
    || expensive_ok_computation()) == Ok(Foo));
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Debug, PartialEq)]
struct Foo;

fn expensive_ok_computation() -> Foo {
    // ...some expensive computation
    Foo
}

#[derive(Debug, PartialEq)]
struct Bar;

fn expensive_err_computation() -> Bar {
    // ...expensive computation
    Bar
}

let vec = vec![1, 2, 3];

// elide `expensive_computation()`
assert!(vec.contains(&4).ok_or_err_with(
    || expensive_err_computation(),
    || expensive_ok_computation()) == Err(Bar));
source

fn map<T>(self, f: T, t: T) -> T

bool => T

§Transforms true => T, false => T
§Examples:
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).map("no", "yes") == "yes");
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).map("no", "yes") == "no");
source

fn map_or<F: FnOnce() -> T, T>(self, f: T, t: F) -> T

bool => T

§Transforms true => T, false => T
§Examples:
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).map_or(0, || {
    //... some computation
    42
}) == 42);
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).map_or(None, || {
    //... some computation
    Some(42)
}) == None);
source

fn map_or_default<F: FnOnce() -> T, T: Default>(self, t: F) -> T

bool => T

§Transforms true => T, false => T::default()
§Examples:
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

let vec = vec![1, 2, 3];

assert!(vec.contains(&2).map_or_default(|| {
    //... some computation
    42
}) == 42);
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

let vec = vec![1, 2, 3];

assert!(vec.contains(&4).map_or_default(|| {
    //... some computation
    Some(42)
}) == None);
source

fn map_or_else<F: FnOnce() -> T, G: FnOnce() -> T, T>(self, f: G, t: F) -> T

bool => T

§Transforms true => T, false => T
§Examples:
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

#[derive(Debug, PartialEq)]
enum SetPresence {
    In,
    Out,
}

let vec = vec![1, 2, 3];

assert_eq!(vec.contains(&2).map_or_else(
    || SetPresence::Out,
    || SetPresence::In), SetPresence::In);
use assert2::assert;
use bool_ext::BoolExt;
use std::fmt::Formatter;

#[derive(Debug, PartialEq)]
enum SetPresence {
    In,
    Out,
}

let vec = vec![1, 2, 3];

assert_eq!(vec.contains(&4).map_or_else(
    || SetPresence::Out,
    || SetPresence::In), SetPresence::Out);
source

fn and_do<F: FnOnce()>(self, t: F) -> bool

§Perform side-effect if true, otherwise do nothing
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

let mut vec = vec![1, 2, 3];
vec.contains(&2).and_do(|| vec.iter_mut().for_each(|el| *el = -*el));
assert!(vec.eq(&[-1, -2, -3]));
source

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

§Perform side-effect if false, otherwise do nothing
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

let mut vec = vec![1, 2, 3];
vec.contains(&4).or_do(|| vec.push(4));
assert!(vec.eq(&[1, 2, 3, 4]));
source

fn and_try_do<F: FnOnce() -> Result<(), E>, E>(self, t: F) -> Result<bool, E>

§Perform fallible side-effect if true, otherwise do nothing
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Clone, Debug, PartialEq)]
enum SomeError {}

let mut vec = vec![1, 2, 3];
vec.contains(&2).and_try_do(|| {
    vec.iter_mut().for_each(|el| *el = -*el);
    Ok::<_, SomeError>(())
});
assert!(vec.eq(&[-1, -2, -3]));
source

fn or_try_do<F: FnOnce() -> Result<(), E>, E>(self, f: F) -> Result<bool, E>

§Perform fallible side-effect if false, otherwise do nothing
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

#[derive(Clone, Debug, PartialEq)]
enum SomeError {}

let mut vec = vec![1, 2, 3];
vec.contains(&4).or_try_do(|| {
    vec.push(4);
    Ok::<_, SomeError>(())
});
assert!(vec.eq(&[1, 2, 3, 4]));
source

fn expect(self, msg: &str)

§Transforms false => panic!()
§panic with message if false, otherwise do nothing
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

let mut vec = vec![1, 2, 3];

let res = std::panic::catch_unwind(|| {
    vec.contains(&2).expect("Test expected `true`, but found `false`");
});
// Did not panic
assert!(res.is_ok());
use assert2::assert;
use bool_ext::BoolExt;

let mut vec = vec![1, 2, 3];
let res = std::panic::catch_unwind(|| {
    vec.contains(&4).expect("Test expected `true`, but found `false`");
});
// Panicked
assert!(res.is_err());
source

fn expect_false(self, msg: &str)

§Transforms true => panic!()
§panic with message if true, otherwise do nothing
§Examples:
use assert2::assert;
use bool_ext::BoolExt;

let supposedly_unique_value = 42;
let values_already_seen = vec![1, 2, 3];

let res = std::panic::catch_unwind(|| {
    values_already_seen.contains(&supposedly_unique_value)
                       .expect_false("Test expected `false`, but found `true`");
});
// Did not panic
assert!(res.is_ok());
use assert2::assert;
use bool_ext::BoolExt;

let supposedly_unique_value = 42;
let values_already_seen = vec![1, 2, 3, 42];

let res = std::panic::catch_unwind(|| {
    values_already_seen.contains(&supposedly_unique_value)
                       .expect_false("Test expected `false`, but found `true`");
});
// Panicked
assert!(res.is_err());

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl BoolExt for bool

source§

fn to_option(self) -> Option<()>

source§

fn some<T>(self, some: T) -> Option<T>

source§

fn some_with<F: FnOnce() -> T, T>(self, some: F) -> Option<T>

source§

fn to_result(self) -> Result<(), ()>

source§

fn and_ok<T>(self, ok: T) -> Result<T, ()>

source§

fn and_ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>

source§

fn or_ok<T>(self, ok: T) -> Result<T, ()>

source§

fn or_ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>

source§

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

source§

fn and_err_with<F: FnOnce() -> E, E>(self, err: F) -> Result<(), E>

source§

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

source§

fn or_err_with<F: FnOnce() -> E, E>(self, err: F) -> Result<(), E>

source§

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

source§

fn ok_or_err_with<F: FnOnce() -> T, G: FnOnce() -> E, T, E>( self, err: G, ok: F ) -> Result<T, E>

source§

fn map<T>(self, f: T, t: T) -> T

source§

fn map_or<F: FnOnce() -> T, T>(self, f: T, t: F) -> T

source§

fn map_or_default<F: FnOnce() -> T, T: Default>(self, t: F) -> T

source§

fn map_or_else<F: FnOnce() -> T, G: FnOnce() -> T, T>(self, f: G, t: F) -> T

source§

fn and_do<F: FnOnce()>(self, t: F) -> bool

source§

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

source§

fn and_try_do<F: FnOnce() -> Result<(), E>, E>(self, t: F) -> Result<bool, E>

source§

fn or_try_do<F: FnOnce() -> Result<(), E>, E>(self, f: F) -> Result<bool, E>

source§

fn expect(self, msg: &str)

source§

fn expect_false(self, msg: &str)

Implementors§