pub struct MutBorrowedBit<'a, B: 'a + BitBlock> { /* private fields */ }Methods from Deref<Target = bool>§
1.62.0 · Sourcepub fn then_some<T>(self, t: T) -> Option<T>
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);1.50.0 · Sourcepub fn then<T, F>(self, f: F) -> Option<T>where
F: FnOnce() -> T,
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);1.98.0 · Sourcepub fn ok_or<E>(self, err: E) -> Result<(), E>
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);1.98.0 · Sourcepub fn ok_or_else<E, F>(self, f: F) -> Result<(), E>where
F: FnOnce() -> E,
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);Sourcepub unsafe fn unchecked_disjoint_bitor(self, rhs: bool) -> bool
🔬This is a nightly-only experimental API. (disjoint_bitor)
pub unsafe fn unchecked_disjoint_bitor(self, rhs: bool) -> bool
disjoint_bitor)Disjoint, bitwise or. Computes self | rhs, assuming at most one, true value.
Practically, this requires that self | rhs and self ^ rhs both yield the
same result, allowing for any of the two to be emitted in codegen – depending
on whichever is cheapest.
§Examples
#![feature(disjoint_bitor)]
assert_eq!(
// SAFETY: Only one, true value is passed.
unsafe { false.unchecked_disjoint_bitor(true) },
true,
);
assert_eq!(
// SAFETY: No true values are passed.
unsafe { false.unchecked_disjoint_bitor(false) },
false,
);§Safety
This results in undefined behaviour if both self and rhs are true.