std::bool

Primitive Type bool

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 always demands a bool value. assert!, being an important macro in testing, checks whether an expression returns true.

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

Trait Implementations

impl Eq for bool [src]

impl Default for bool [src]

fn default() -> bool

impl BitAnd<bool> for bool [src]

type Output = bool

fn bitand(self, rhs: bool) -> bool

impl<'a> BitAnd<bool> for &'a bool [src]

type Output = <bool as BitAnd<bool>>::Output

fn bitand(self, other: bool) -> <bool as BitAnd<bool>>::Output

impl<'a> BitAnd<&'a bool> for bool [src]

type Output = <bool as BitAnd<bool>>::Output

fn bitand(self, other: &'a bool) -> <bool as BitAnd<bool>>::Output

impl<'a, 'b> BitAnd<&'a bool> for &'b bool [src]

type Output = <bool as BitAnd<bool>>::Output

fn bitand(self, other: &'a bool) -> <bool as BitAnd<bool>>::Output

impl BitXorAssign<bool> for bool

1.8.0

[src]

fn bitxor_assign(&mut self, other: bool)

impl Debug for bool [src]

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

impl BitAndAssign<bool> for bool

1.8.0

[src]

fn bitand_assign(&mut self, other: bool)

impl Ord for bool [src]

fn cmp(&self, other: &bool) -> Ordering

impl PartialEq<bool> for bool [src]

fn eq(&self, other: &bool) -> bool

fn ne(&self, other: &bool) -> bool

impl BitXor<bool> for bool [src]

type Output = bool

fn bitxor(self, other: bool) -> bool

impl<'a> BitXor<bool> for &'a bool [src]

type Output = <bool as BitXor<bool>>::Output

fn bitxor(self, other: bool) -> <bool as BitXor<bool>>::Output

impl<'a> BitXor<&'a bool> for bool [src]

type Output = <bool as BitXor<bool>>::Output

fn bitxor(self, other: &'a bool) -> <bool as BitXor<bool>>::Output

impl<'a, 'b> BitXor<&'a bool> for &'b bool [src]

type Output = <bool as BitXor<bool>>::Output

fn bitxor(self, other: &'a bool) -> <bool as BitXor<bool>>::Output

impl Clone for bool [src]

fn clone(&self) -> bool

fn clone_from(&mut self, source: &Self)

impl Not for bool [src]

type Output = bool

fn not(self) -> bool

impl<'a> Not for &'a bool [src]

type Output = <bool as Not>::Output

fn not(self) -> <bool as Not>::Output

impl PartialOrd<bool> for bool [src]

fn partial_cmp(&self, other: &bool) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl Display for bool [src]

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

impl Hash for bool [src]

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

1.3.0

impl FromStr for bool [src]

type Err = ParseBoolError

fn from_str(s: &str) -> Result<bool, ParseBoolError>

use std::str::FromStr;

assert_eq!(FromStr::from_str("true"), Ok(true));
assert_eq!(FromStr::from_str("false"), Ok(false));
assert!(<bool as FromStr>::from_str("not even a boolean").is_err());

assert_eq!("true".parse(), Ok(true));
assert_eq!("false".parse(), Ok(false));
assert!("not even a boolean".parse::<bool>().is_err());

impl BitOrAssign<bool> for bool

1.8.0

[src]

fn bitor_assign(&mut self, other: bool)

impl BitOr<bool> for bool [src]

type Output = bool

fn bitor(self, rhs: bool) -> bool

impl<'a> BitOr<bool> for &'a bool [src]

type Output = <bool as BitOr<bool>>::Output

fn bitor(self, other: bool) -> <bool as BitOr<bool>>::Output

impl<'a> BitOr<&'a bool> for bool [src]

type Output = <bool as BitOr<bool>>::Output

fn bitor(self, other: &'a bool) -> <bool as BitOr<bool>>::Output

impl<'a, 'b> BitOr<&'a bool> for &'b bool [src]

type Output = <bool as BitOr<bool>>::Output

fn bitor(self, other: &'a bool) -> <bool as BitOr<bool>>::Output