Trait bool_ext::BoolExt

pub trait BoolExt {
    fn as_option(self) -> Option<()>;
    fn some<T>(self, some: T) -> Option<T>;
    fn some_with<F: FnOnce() -> T, T>(self, some: F) -> Option<T>;
    fn as_result(self) -> Result<(), ()>;
    fn ok<T>(self, ok: T) -> Result<T, ()>;
    fn ok_with<F: FnOnce() -> T, T>(self, ok: F) -> Result<T, ()>;
    fn ok_or_err<T, E>(self, ok: T, err: E) -> Result<T, E>;
    fn ok_or_err_with<F: FnOnce() -> T, G: FnOnce() -> E, T, E>(
        self, 
        ok: F, 
        err: G
    ) -> Result<T, E>;
    fn map_or<F: FnOnce() -> T, T>(self, default: 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, t: F, f: G) -> T;
    fn and_do<F: FnOnce()>(self, t: F) -> bool;
    fn or_do<F: FnOnce()>(self, f: F) -> bool;
    fn expect(self, msg: &str);
}

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

Required methods

fn as_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).as_option() == Some(()));

use assert2::assert;
use bool_ext::BoolExt;

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

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

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);

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);

fn as_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).as_result() == Ok(()));

use assert2::assert;
use bool_ext::BoolExt;

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

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

fn 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).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).ok(Foo) == Err(()));

fn 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![1, 2, 3];

assert!(vec.contains(&2).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.contains(&4).ok_with(|| expensive_computation()) == Err(()));

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

Transforms true => Ok(T), false => Err(E)

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(Foo, Error) == Ok(Foo));

use assert2::assert;
use bool_ext::BoolExt;

#[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(&4).ok_or_err(Foo, Error) == Err(Error));

fn ok_or_err_with<F: FnOnce() -> T, G: FnOnce() -> E, T, E>(
    self,
    ok: F,
    err: G
) -> 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_ok_computation(),
    || expensive_err_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_ok_computation(),
    || expensive_err_computation()) == Err(Bar));

fn map_or<F: FnOnce() -> T, T>(self, default: T, 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)]

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;

#[derive(Debug, PartialEq)]

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

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

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;

#[derive(Debug, PartialEq)]

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;

#[derive(Debug, PartialEq)]

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

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

fn map_or_else<F: FnOnce() -> T, G: FnOnce() -> T, T>(self, t: F, f: G) -> 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!(vec.contains(&2).map_or_else(
    || SetPresence::In,
    || SetPresence::Out) == 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!(vec.contains(&4).map_or_else(
    || SetPresence::In,
    || SetPresence::Out) == SetPresence::Out);

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;

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

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]));

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;

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

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

fn expect(self, msg: &str)

Transforms false => panic!()

panic with message if false, otherwise do nothing

Examples:

use assert2::assert;
use bool_ext::BoolExt;

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

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;

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

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());

Loading content...

Implementations on Foreign Types

impl BoolExt for bool

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

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

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

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

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

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

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

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

fn map_or<F: FnOnce() -> T, T>(self, default: 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, t: F, f: G) -> T

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

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

fn expect(self, msg: &str)

Loading content...

Implementors

Loading content...