[−][src]Trait bool_ext::BoolExt

pub trait BoolExt {
    fn as_option(self) -> Option<()>;

    fn as_option_false(self) -> Option<()>;

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

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

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

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

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

    fn as_result_false(self) -> Result<(), ()>;

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

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

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

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

    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 ok_or_err_false<T, E>(self, ok: T, err: E) -> Result<T, E>;

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

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

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

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

    fn expect(self, msg: &str);

    fn expect_false(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 bool_ext::BoolExt;

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

assert_eq!(vec.contains(&2).as_option(), Some(()));
use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&4).as_option(), None);

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

Transforms true => None, false => Some(())

Examples:

use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&2).as_option_false(), None);
use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&4).as_option_false(), Some(()));

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

Transforms true => Some(T), false => None

Examples:

use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&2).some(Foo), Some(Foo));
use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&4).some(Foo), None);

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

Transforms true => None, false => Some(T)

Examples:

use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&2).some_false(Foo), None);
use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&4).some_false(Foo), Some(Foo));

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

Transforms true => Some(T), false => None, lazily evaluated

Examples:

use bool_ext::BoolExt;

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

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

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

assert_eq!(vec.contains(&2).some_with(|| expensive_computation()), Some(Foo));
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_eq!(vec.contains(&4).some_with(|| expensive_computation()), None);

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

Transforms true => None, false => Some(T), lazily evaluated

use bool_ext::BoolExt;

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

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

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

// elide `expensive_computation()`
assert_eq!(vec.contains(&2).some_with_false(|| expensive_computation()), None);
use bool_ext::BoolExt;

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

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

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

assert_eq!(vec.contains(&4).some_with_false(|| expensive_computation()), Some(Foo));

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

bool => Result<T, E>

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

Examples:

use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&2).as_result(), Ok(()));
use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&4).as_result(), Err(()));

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

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

Examples:

use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&2).as_result_false(), Err(()));
use bool_ext::BoolExt;

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

assert_eq!(vec.contains(&4).as_result_false(), Ok(()));

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

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

Examples:

use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&2).ok(Foo), Ok(Foo));
use bool_ext::BoolExt;

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

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

assert_eq!(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 bool_ext::BoolExt;

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

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

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

assert_eq!(vec.contains(&2).ok_with(|| expensive_computation()), Ok(Foo));
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_eq!(vec.contains(&4).ok_with(|| expensive_computation()), Err(()));

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

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

Examples:

use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&2).ok_false(Foo), Err(Foo));
use bool_ext::BoolExt;

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

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

assert_eq!(vec.contains(&4).ok_false(Foo), Ok(()));

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

Transforms true => Ok(()), false => Err(E), lazily evaluated

Examples:

use bool_ext::BoolExt;

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

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

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

assert_eq!(vec.contains(&2).ok_with(|| expensive_computation()), Ok(Foo));
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_eq!(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 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_eq!(vec.contains(&2).ok_or_err(Foo, Error), Ok(Foo));
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_eq!(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 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_eq!(vec.contains(&2).ok_or_err_with(
    || expensive_ok_computation(),
    || expensive_err_computation()), Ok(Foo));
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_eq!(vec.contains(&4).ok_or_err_with(
    || expensive_ok_computation(),
    || expensive_err_computation()), Err(Bar));

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

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

Examples:

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_eq!(vec.contains(&2).ok_or_err_false(Foo, Error), Err(Error));
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_eq!(vec.contains(&4).ok_or_err_false(Foo, Error), Ok(Foo));

fn ok_or_err_false_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 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_eq!(vec.contains(&2).ok_or_err_false_with(
    || expensive_ok_computation(),
    || expensive_err_computation()), Err(Bar));
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_eq!(vec.contains(&4).ok_or_err_false_with(
    || expensive_ok_computation(),
    || expensive_err_computation()), Ok(Foo));

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

bool => T

Transforms true => T, false => T

Examples:

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(|| SetPresence::In, || SetPresence::Out), SetPresence::In);
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(|| SetPresence::In, || SetPresence::Out), SetPresence::Out);

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

Perform side-effect if true, otherwise do nothing

Examples:

use bool_ext::BoolExt;

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

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

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

Perform side-effect if false, otherwise do nothing

Examples:

use bool_ext::BoolExt;

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

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

fn expect(self, msg: &str)

Transforms false => panic!()

panic with message if false, otherwise do nothing

Examples:

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

fn expect_false(self, msg: &str)

Transforms true => panic!()

panic with message if true, otherwise do nothing

Examples:

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_false("Test expected `false`, but found `true`");
});
// Did not panic
assert!(res.is_ok());
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_false("Test expected `false`, but found `true`");
});
// Panicked
assert!(res.is_err());
Loading content...

Implementations on Foreign Types

impl BoolExt for bool[src]

Loading content...

Implementors

Loading content...