bool - Rust (original) (raw)

Expand description

The boolean type.

The bool represents a value, which could only be either true or false. If you cast a bool into an integer, true will be 1 and false will be 0.

§Basic usage

bool implements various traits, such as BitAnd, BitOr, Not, etc., which allow us to perform boolean operations using &, | and !.

if requires a bool value as its conditional. assert!, which is an important macro in testing, checks whether an expression is true and panics if it isn’t.

let bool_val = true & false | false;
assert!(!bool_val);

§Examples

A trivial example of the usage of bool:

let praise_the_borrow_checker = true;

// using the `if` conditional
if praise_the_borrow_checker {
    println!("oh, yeah!");
} else {
    println!("what?!!");
}

// ... or, a match pattern
match praise_the_borrow_checker {
    true => println!("keep praising!"),
    false => println!("you should praise!"),
}

Also, since bool implements the Copy trait, we don’t have to worry about the move semantics (just like the integer and float primitives).

Now an example of bool cast to integer type:

assert_eq!(true as i32, 1);
assert_eq!(false as i32, 0);

Source §

1.62.0 · Source

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 usethen, 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 · Source

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

Source

🔬This is a nightly-only experimental API. (select_unpredictable #133962)

Returns either true_val or false_val depending on the value ofself, with a hint to the compiler that self is unlikely to be correctly predicted by a CPU’s branch predictor.

This method is functionally equivalent to

ⓘ

fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
    if b { true_val } else { false_val }
}

but might generate different assembly. In particular, on platforms with a conditional move or select instruction (like cmov on x86 or cselon ARM) the optimizer might use these instructions to avoid branches, which can benefit performance if the branch predictor is struggling with predicting condition, such as in an implementation of binary search.

Note however that this lowering is not guaranteed (on any platform) and should not be relied upon when trying to write constant-time code. Also be aware that this lowering might decrease performance if conditionis well-predictable. It is advisable to perform benchmarks to tell if this function is useful.

§Examples

Distribute values evenly between two buckets:

#![feature(select_unpredictable)]

use std::hash::BuildHasher;

fn append<H: BuildHasher>(hasher: &H, v: i32, bucket_one: &mut Vec<i32>, bucket_two: &mut Vec<i32>) {
    let hash = hasher.hash_one(&v);
    let bucket = (hash % 2 == 0).select_unpredictable(bucket_one, bucket_two);
    bucket.push(v);
}

1.0.0 · Source §

Source §