Boolean type

#![allow(unused)]
fn main() {
let b: bool = true;
}

The boolean type or bool is a primitive data type that can take on one of two values, called true and false.

Values of this type may be created using a literal expression using the keywords true and false corresponding to the value of the same name.

This type is a part of the language prelude with the name bool.

An object with the boolean type has a size and alignment of 1 each. The value false has the bit pattern 0x00 and the value true has the bit pattern 0x01. It is undefined behavior for an object with the boolean type to have any other bit pattern.

The boolean type is the type of many operands in various expressions:

Note: The boolean type acts similarly to but is not an enumerated type. In practice, this mostly means that constructors are not associated to the type (e.g. bool::true).

Like all primitives, the boolean type implements the traits Clone, Copy, Sized, Send, and Sync.

Note: See the standard library docs for library operations.

Operations on boolean values

When using certain operator expressions with a

boolean type for its operands, they evaluate using the rules of boolean logic.

Logical not

b!b
truefalse
falsetrue

Logical or

aba | b
truetruetrue
truefalsetrue
falsetruetrue
falsefalsefalse

Logical and

aba & b
truetruetrue
truefalsefalse
falsetruefalse
falsefalsefalse

Logical xor

aba ^ b
truetruefalse
truefalsetrue
falsetruetrue
falsefalsefalse

Comparisons

aba == b
truetruetrue
truefalsefalse
falsetruefalse
falsefalsetrue
aba > b
truetruefalse
truefalsetrue
falsetruefalse
falsefalsefalse
  • a != b is the same as !(a == b)
  • a >= b is the same as a == b | a > b
  • a < b is the same as !(a >= b)
  • a <= b is the same as a == b | a < b

Bit validity

The single byte of a bool is guaranteed to be initialized (in other words, transmute::<bool, u8>(...) is always sound – but since some bit patterns are invalid bools, the inverse is not always sound).