Struct MutBorrowedBit 

pub struct MutBorrowedBit<'a, B: 'a + BitBlock> { /* private fields */ }

Methods from Deref<Target = bool>

pub fn then_some<T>(self, t: T) -> Option<T>

Returns Some(t) if the bool is true, or None otherwise.

Arguments passed to then_some are eagerly evaluated; if you are passing the result of a function call, it is recommended to use then, which is lazily evaluated.

Examples

assert_eq!(false.then_some(0), None);
assert_eq!(true.then_some(0), Some(0));

let mut a = 0;
let mut function_with_side_effects = || { a += 1; };

true.then_some(function_with_side_effects());
false.then_some(function_with_side_effects());

// `a` is incremented twice because the value passed to `then_some` is
// evaluated eagerly.
assert_eq!(a, 2);

pub fn then<T, F>(self, f: F) -> Option<T>

where F: FnOnce() -> T,

Returns Some(f()) if the bool is true, or None otherwise.

Examples

assert_eq!(false.then(|| 0), None);
assert_eq!(true.then(|| 0), Some(0));

let mut a = 0;

true.then(|| { a += 1; });
false.then(|| { a += 1; });

// `a` is incremented once because the closure is evaluated lazily by
// `then`.
assert_eq!(a, 1);

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

Returns Ok(()) if the bool is true, or Err(err) otherwise.

Arguments passed to ok_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use ok_or_else, which is lazily evaluated.

Examples

assert_eq!(false.ok_or(0), Err(0));
assert_eq!(true.ok_or(0), Ok(()));

let mut a = 0;
let mut function_with_side_effects = || { a += 1; };

assert!(true.ok_or(function_with_side_effects()).is_ok());
assert!(false.ok_or(function_with_side_effects()).is_err());

// `a` is incremented twice because the value passed to `ok_or` is
// evaluated eagerly.
assert_eq!(a, 2);

pub fn ok_or_else<E, F>(self, f: F) -> Result<(), E>

where F: FnOnce() -> E,

Returns Ok(()) if the bool is true, or Err(f()) otherwise.

Examples

assert_eq!(false.ok_or_else(|| 0), Err(0));
assert_eq!(true.ok_or_else(|| 0), Ok(()));

let mut a = 0;

assert!(true.ok_or_else(|| { a += 1; }).is_ok());
assert!(false.ok_or_else(|| { a += 1; }).is_err());

// `a` is incremented once because the closure is evaluated lazily by
// `ok_or_else`.
assert_eq!(a, 1);

pub fn toggle(&mut self)

Toggles self in-place.

• If self is true, sets self to false.
• If self is false, sets self to true.

Equivalent to value = !value.

Examples

let mut boolean = false;

boolean.toggle();
assert_eq!(boolean, true);

boolean.toggle();
assert_eq!(boolean, false);

Trait Implementations

impl<'a, B: Debug + 'a + BitBlock> Debug for MutBorrowedBit<'a, B>

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

Formats the value using the given formatter.

impl<'a, B: BitBlock> Deref for MutBorrowedBit<'a, B>

type Target = bool

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, B: BitBlock> DerefMut for MutBorrowedBit<'a, B>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, B: BitBlock> Drop for MutBorrowedBit<'a, B>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.