Introduction to Booleans in Rust

Booleans are one of the simplest and most fundamental data types in Rust, representing logical true/false values. They are essential for control flow, conditional logic, and decision-making in programs. Rust's boolean type is designed with type safety and clarity in mind, preventing common errors found in languages with truthy/falsy conversions.

Key Concepts

• Type Name: bool
• Size: 1 byte (8 bits)
• Values: true and false (both are keywords)
• Memory Representation: true is 1, false is 0
• Type Safety: No implicit conversions to/from other types
• Zero-Cost: Compiles to efficient machine code

1. Boolean Basics

Declaring Booleans

fn main() { // Basic boolean declaration let is_active = true; let is_completed: bool = false; // Multiple declarations let (is_ready, is_valid, is_running) = (true, false, true); println!("is_active: {}", is_active); println!("is_completed: {}", is_completed); println!("is_ready: {}, is_valid: {}, is_running: {}", is_ready, is_valid, is_running); // Boolean from expressions let x = 5; let y = 10; let is_greater = x > y; let is_equal = x == y; let is_less_or_equal = x <= y; println!("x > y: {}", is_greater); println!("x == y: {}", is_equal); println!("x <= y: {}", is_less_or_equal); // Boolean literals are keywords let t = true; let f = false; // Boolean in structs #[derive(Debug)] struct User { username: String, is_active: bool, is_admin: bool, } let user = User { username: String::from("alice"), is_active: true, is_admin: false, }; println!("User: {:?}", user); }

Boolean Size and Memory

use std::mem; fn main() { // Size of bool println!("Size of bool: {} byte(s)", mem::size_of::<bool>()); println!("Size of bool reference: {} bytes", mem::size_of::<&bool>()); println!("Size of Option<bool>: {} bytes", mem::size_of::<Option<bool>>()); // Alignment println!("Alignment of bool: {}", mem::align_of::<bool>()); // Memory representation (implementation detail) let t: bool = true; let f: bool = false; // Unsafe to view raw bytes (for illustration only) unsafe { let t_bytes: *const u8 = &t as *const bool as *const u8; let f_bytes: *const u8 = &f as *const bool as *const u8; println!("true in memory: {:08b}", *t_bytes); println!("false in memory: {:08b}", *f_bytes); } // Arrays of booleans let bool_array = [true, false, true, true, false]; println!("Array of 5 bools size: {} bytes", mem::size_of_val(&bool_array)); // Vector of booleans let bool_vec = vec![true, false, true]; println!("Vector of 3 bools heap size: dynamic"); }

2. Boolean Operations

Logical Operators

fn main() { let t = true; let f = false; // Logical AND (&&) - returns true if both operands are true println!("true && true: {}", t && t); // true println!("true && false: {}", t && f); // false println!("false && true: {}", f && t); // false println!("false && false: {}", f && f); // false // Logical OR (||) - returns true if at least one operand is true println!("true || true: {}", t || t); // true println!("true || false: {}", t || f); // true println!("false || true: {}", f || t); // true println!("false || false: {}", f || f); // false // Logical NOT (!) - negates the boolean println!("!true: {}", !t); // false println!("!false: {}", !f); // true // Chaining logical operations let result = (t && f) || (t || f) && !f; println!("Complex expression: {}", result); // Precedence: ! has highest, then &&, then || // This is equivalent to: (t && f) || ((t || f) && (!f)) let result2 = t && f || t || f && !f; println!("Same without parentheses: {}", result2); }

Short-Circuit Evaluation

fn main() { // AND short-circuits: if first operand is false, second is not evaluated fn expensive_check() -> bool { println!("Expensive check executed"); true } println!("Short-circuit with &&:"); let result = false && expensive_check(); println!("Result: {} (expensive_check not called)\n", result); let result = true && expensive_check(); println!("Result: {} (expensive_check called)\n", result); // OR short-circuits: if first operand is true, second is not evaluated println!("Short-circuit with ||:"); let result = true || expensive_check(); println!("Result: {} (expensive_check not called)\n", result); let result = false || expensive_check(); println!("Result: {} (expensive_check called)\n", result); // Practical use: guard conditions let numbers = vec![1, 2, 3, 4, 5]; let index = 10; // Safe access with short-circuit if index < numbers.len() && numbers[index] > 3 { println!("Found value > 3 at index {}", index); } else { println!("Index out of bounds or value not > 3"); } // Short-circuit prevents out-of-bounds access // Another example: checking multiple conditions fn validate_input(input: &str) -> bool { !input.is_empty() && input.len() <= 10 && input.chars().all(char::is_alphanumeric) } println!("Valid 'hello123': {}", validate_input("hello123")); println!("Valid '': {}", validate_input("")); println!("Valid 'verylonginputthatistoolong': {}", validate_input("verylonginputthatistoolong")); }

3. Booleans from Comparisons

Comparison Operators

fn main() { let a = 5; let b = 10; let c = 5; // Equality comparisons let is_equal = a == b; // false let is_not_equal = a != b; // true let a_equals_c = a == c; // true println!("a == b: {}", is_equal); println!("a != b: {}", is_not_equal); println!("a == c: {}", a_equals_c); // Ordering comparisons let is_greater = a > b; // false let is_less = a < b; // true let is_greater_or_equal = a >= c; // true let is_less_or_equal = a <= b; // true println!("a > b: {}", is_greater); println!("a < b: {}", is_less); println!("a >= c: {}", is_greater_or_equal); println!("a <= b: {}", is_less_or_equal); // Comparing different numeric types (requires explicit conversion) let x: i32 = 5; let y: f64 = 5.0; // println!("{}", x == y); // Error: mismatched types println!("x == y as i32: {}", x == y as i32); println!("x as f64 == y: {}", x as f64 == y); // String comparisons let s1 = String::from("hello"); let s2 = String::from("hello"); let s3 = "hello"; let s4 = String::from("world"); println!("s1 == s2: {}", s1 == s2); // true println!("s1 == s3: {}", s1 == s3); // true (&str comparison works) println!("s1 == s4: {}", s1 == s4); // false println!("s1 < s4: {}", s1 < s4); // true (lexicographic) }

Chaining Comparisons

fn main() { let x = 5; // Rust doesn't allow chained comparisons like 0 < x < 10 // This would be an error: // if 0 < x < 10 { // println!("x is between 0 and 10"); // } // Instead, use && operator if 0 < x && x < 10 { println!("x is between 0 and 10 (exclusive)"); } // Inclusive range if 0 <= x && x <= 10 { println!("x is between 0 and 10 (inclusive)"); } // Multiple conditions let age = 25; let has_license = true; let is_insured = false; if age >= 18 && has_license && is_insured { println!("Can drive legally"); } else { println!("Cannot drive legally"); } // Complex condition let temperature = 22; let is_raining = false; let is_weekend = true; let go_outside = (temperature > 20 && !is_raining) || (is_weekend && temperature > 15); println!("Should go outside: {}", go_outside); }

4. Booleans in Control Flow

If Expressions

fn main() { let condition = true; // Basic if if condition { println!("Condition is true"); } // if-else let number = 7; if number < 5 { println!("Number is less than 5"); } else { println!("Number is greater than or equal to 5"); } // if-else if-else if number % 4 == 0 { println!("Number divisible by 4"); } else if number % 3 == 0 { println!("Number divisible by 3"); } else if number % 2 == 0 { println!("Number divisible by 2"); } else { println!("Number not divisible by 4, 3, or 2"); } // if as an expression (returns value) let condition = true; let value = if condition { 5 } else { 10 }; println!("Value from if expression: {}", value); // Both arms must return same type let is_even = number % 2 == 0; let description = if is_even { "even" } else { "odd" }; println!("Number is {}", description); // Using boolean in loop conditions let mut counter = 0; let mut running = true; while running { counter += 1; println!("Counter: {}", counter); if counter >= 5 { running = false; } } }

Match with Booleans

fn main() { // Match on boolean (though if is usually simpler) let flag = true; match flag { true => println!("Flag is true"), false => println!("Flag is false"), } // Match with boolean patterns let (x, y) = (5, 10); match (x < y, x == y, x > y) { (true, _, _) => println!("x is less than y"), (_, true, _) => println!("x equals y"), (_, _, true) => println!("x is greater than y"), _ => unreachable!(), } // Match guards with booleans let pair = (5, -5); match pair { (x, y) if x == y => println!("Equal"), (x, y) if x + y == 0 => println!("Opposites"), (x, y) if x % 2 == 0 => println!("First is even"), _ => println!("No match"), } // Boolean in match patterns let optional = Some(5); match optional { Some(x) if x > 0 => println!("Positive number: {}", x), Some(x) if x < 0 => println!("Negative number: {}", x), Some(0) => println!("Zero"), None => println!("Nothing"), _ => println!("Some other value"), } }

5. Boolean Methods and Functions

Boolean Methods

fn main() { // then() - returns Option let flag = true; let result = flag.then(|| 42); println!("then() with true: {:?}", result); // Some(42) let flag = false; let result = flag.then(|| 42); println!("then() with false: {:?}", result); // None // then_some() - directly returns Option with value let flag = true; let result = flag.then_some("yes"); println!("then_some() with true: {:?}", result); // Some("yes") let flag = false; let result = flag.then_some("yes"); println!("then_some() with false: {:?}", result); // None // Not() for bitwise NOT (but this is for bool, use !) let flag = true; println!("!flag: {}", !flag); // There's no direct methods like to_u32, but we can cast let flag = true; let as_int = flag as u8; println!("true as u8: {}", as_int); // 1 let flag = false; let as_int = flag as u8; println!("false as u8: {}", as_int); // 0 // Converting to string let flag = true; let as_string = flag.to_string(); println!("as string: {}", as_string); // "true" }

Utility Functions

fn main() { // Parsing booleans from strings let parsed_true: bool = "true".parse().unwrap(); let parsed_false: bool = "false".parse().unwrap(); println!("Parsed 'true': {}", parsed_true); println!("Parsed 'false': {}", parsed_false); // Handling parse errors match "TRUE".to_lowercase().parse::<bool>() { Ok(val) => println!("Parsed: {}", val), Err(e) => println!("Error: {}", e), } // Converting from integers (not direct, but via comparison) let num = 1; let bool_from_int = num != 0; println!("1 != 0: {}", bool_from_int); let num = 0; let bool_from_int = num != 0; println!("0 != 0: {}", bool_from_int); // Custom conversion function fn to_bool<T: PartialEq + Default>(value: T) -> bool { value != T::default() } println!("to_bool(5): {}", to_bool(5)); println!("to_bool(0): {}", to_bool(0)); println!("to_bool(\"hello\"): {}", to_bool("hello")); println!("to_bool(\"\"): {}", to_bool("")); // Checking string content let s = "true"; let is_true = s == "true" || s == "yes" || s == "1"; println!("String '{}' is truthy: {}", s, is_true); }

6. Booleans with Option and Result

Option

fn main() { // Option<bool> represents three states: Some(true), Some(false), None let maybe_true: Option<bool> = Some(true); let maybe_false: Option<bool> = Some(false); let maybe_none: Option<bool> = None; // Processing Option<bool> fn process_bool_option(opt: Option<bool>) { match opt { Some(true) => println!("Definitely true"), Some(false) => println!("Definitely false"), None => println!("Undefined"), } } process_bool_option(maybe_true); process_bool_option(maybe_false); process_bool_option(maybe_none); // Combining Option<bool> with logical operations let a = Some(true); let b = Some(false); let c = None; // AND operation on Option<bool> let and_result = a.and(b); println!("Some(true) and Some(false): {:?}", and_result); let and_result = a.and(c); println!("Some(true) and None: {:?}", and_result); // OR operation on Option<bool> let or_result = a.or(b); println!("Some(true) or Some(false): {:?}", or_result); let or_result = c.or(b); println!("None or Some(false): {:?}", or_result); // XOR not directly available, but can be implemented fn xor_option(a: Option<bool>, b: Option<bool>) -> Option<bool> { match (a, b) { (Some(true), Some(false)) | (Some(false), Some(true)) => Some(true), (Some(x), Some(y)) => Some(x == y), _ => None, } } println!("XOR Some(true), Some(false): {:?}", xor_option(Some(true), Some(false))); println!("XOR Some(true), Some(true): {:?}", xor_option(Some(true), Some(true))); }

Result

#[derive(Debug)] enum ValidationError { Empty, TooLong, InvalidChars, } fn validate_username(username: &str) -> Result<bool, ValidationError> { if username.is_empty() { Err(ValidationError::Empty) } else if username.len() > 20 { Err(ValidationError::TooLong) } else if !username.chars().all(|c| c.is_alphanumeric()) { Err(ValidationError::InvalidChars) } else { Ok(true) // Username is valid } } fn main() { let usernames = vec!["", "alice", "thisusernameiswaytoolong", "bob@123", "charlie"]; for name in usernames { match validate_username(name) { Ok(valid) => println!("'{}' is valid: {}", name, valid), Err(e) => println!("'{}' invalid: {:?}", name, e), } } // Using Result<bool, E> with boolean operations let result1: Result<bool, &str> = Ok(true); let result2: Result<bool, &str> = Ok(false); let result3: Result<bool, &str> = Err("error"); // Combining with and_then let combined = result1.and_then(|b1| { result2.map(|b2| b1 && b2) }); println!("true && false = {:?}", combined); // Using ? operator fn check_all() -> Result<bool, &str> { let a = result1?; let b = result2?; // let c = result3?; // This would propagate the error Ok(a && b) } println!("check_all(): {:?}", check_all()); }

7. Bitwise Operations on Booleans

Boolean Bitwise Operations

fn main() { let t = true; let f = false; // Bitwise AND (different from logical AND - no short-circuit) let bitwise_and = t & t; // true let bitwise_and2 = t & f; // false println!("true & true: {}", bitwise_and); println!("true & false: {}", bitwise_and2); // Bitwise OR let bitwise_or = t | f; // true let bitwise_or2 = f | f; // false println!("true | false: {}", bitwise_or); println!("false | false: {}", bitwise_or2); // Bitwise XOR let bitwise_xor = t ^ f; // true let bitwise_xor2 = t ^ t; // false println!("true ^ false: {}", bitwise_xor); println!("true ^ true: {}", bitwise_xor2); // Bitwise NOT (same as logical NOT for single bool) let bitwise_not = !t; println!("!true: {}", bitwise_not); // Important: Bitwise operators don't short-circuit fn side_effect() -> bool { println!("Side effect executed!"); true } println!("\nLogical AND (short-circuits):"); let result = false && side_effect(); println!("\nBitwise AND (no short-circuit):"); let result = false & side_effect(); }

Using Booleans for Flags

// Using bool in bitflags (though bitflags crate is better for complex cases) #[derive(Debug, Clone, Copy)] struct Permissions { read: bool, write: bool, execute: bool, } impl Permissions { fn new() -> Self { Permissions { read: false, write: false, execute: false, } } fn to_byte(&self) -> u8 { (self.read as u8) << 2 | (self.write as u8) << 1 | (self.execute as u8) } fn from_byte(byte: u8) -> Self { Permissions { read: (byte & 0b100) != 0, write: (byte & 0b010) != 0, execute: (byte & 0b001) != 0, } } fn can_read_and_write(&self) -> bool { self.read && self.write } fn can_execute(&self) -> bool { self.execute } } fn main() { let mut perms = Permissions::new(); perms.read = true; perms.write = true; println!("Permissions: read={}, write={}, execute={}", perms.read, perms.write, perms.execute); println!("As byte: {:03b}", perms.to_byte()); let perms2 = Permissions::from_byte(0b101); println!("From byte 101: read={}, write={}, execute={}", perms2.read, perms2.write, perms2.execute); println!("Can read and write: {}", perms.can_read_and_write()); println!("Can execute: {}", perms.can_execute()); }

8. Booleans in Traits and Generics

Boolean Associated Types

trait Condition { fn check(&self) -> bool; } struct GreaterThan<T: PartialOrd> { value: T, threshold: T, } impl<T: PartialOrd> Condition for GreaterThan<T> { fn check(&self) -> bool { self.value > self.threshold } } struct AndCondition<A: Condition, B: Condition> { left: A, right: B, } impl<A: Condition, B: Condition> Condition for AndCondition<A, B> { fn check(&self) -> bool { self.left.check() && self.right.check() } } struct OrCondition<A: Condition, B: Condition> { left: A, right: B, } impl<A: Condition, B: Condition> Condition for OrCondition<A, B> { fn check(&self) -> bool { self.left.check() || self.right.check() } } fn main() { let cond1 = GreaterThan { value: 10, threshold: 5, }; let cond2 = GreaterThan { value: 3, threshold: 8, }; let and_cond = AndCondition { left: cond1, right: cond2, }; let or_cond = OrCondition { left: cond1, right: cond2, }; println!("cond1: {}", cond1.check()); println!("cond2: {}", cond2.check()); println!("AND: {}", and_cond.check()); println!("OR: {}", or_cond.check()); }

Generic Boolean Functions

use std::cmp::PartialOrd; // Generic function with boolean return fn all_true<T, F>(items: &[T], predicate: F) -> bool where F: Fn(&T) -> bool, { items.iter().all(predicate) } fn any_true<T, F>(items: &[T], predicate: F) -> bool where F: Fn(&T) -> bool, { items.iter().any(predicate) } fn none_true<T, F>(items: &[T], predicate: F) -> bool where F: Fn(&T) -> bool, { !items.iter().any(predicate) } // Generic comparison fn is_between<T: PartialOrd>(value: T, low: T, high: T) -> bool { low <= value && value <= high } fn main() { let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let all_even = all_true(&numbers, |&x| x % 2 == 0); let any_even = any_true(&numbers, |&x| x % 2 == 0); let all_positive = all_true(&numbers, |&x| x > 0); println!("All even: {}", all_even); println!("Any even: {}", any_even); println!("All positive: {}", all_positive); println!("5 between 1 and 10: {}", is_between(5, 1, 10)); println!("15 between 1 and 10: {}", is_between(15, 1, 10)); let strings = vec!["apple", "banana", "cherry"]; let has_long = any_true(&strings, |&s| s.len() > 5); println!("Any string longer than 5: {}", has_long); }

9. Performance and Optimization

Boolean Efficiency

use std::time::Instant; fn main() { // Booleans are very efficient // Branch prediction example let mut data = vec![0; 1000000]; for i in 0..data.len() { data[i] = (i % 2) as i32; } // Version with branch let start = Instant::now(); let mut sum_branch = 0; for &x in &data { if x == 1 { sum_branch += x; } } let branch_time = start.elapsed(); // Version with multiplication (branchless) let start = Instant::now(); let mut sum_branchless = 0; for &x in &data { sum_branchless += x * (x == 1) as i32; } let branchless_time = start.elapsed(); println!("Branch version: {:?}", branch_time); println!("Branchless version: {:?}", branchless_time); println!("Sum (branch): {}", sum_branch); println!("Sum (branchless): {}", sum_branchless); // Boolean to integer conversion is cheap let flag = true; let as_int = flag as u8; // Very cheap operation }

Memory Layout Optimization

#[derive(Debug)] struct WithoutOptimization { flag1: bool, value1: u32, flag2: bool, value2: u64, flag3: bool, } #[derive(Debug)] struct WithOptimization { flags: [bool; 3], value1: u32, value2: u64, } fn main() { use std::mem; println!("Size of bool: {} bytes", mem::size_of::<bool>()); // Due to padding, bools can waste space println!("Size of WithoutOptimization: {} bytes", mem::size_of::<WithoutOptimization>()); println!("Size of WithOptimization: {} bytes", mem::size_of::<WithOptimization>()); // Packing bools together saves space let unoptimized = WithoutOptimization { flag1: true, value1: 42, flag2: false, value2: 100, flag3: true, }; let optimized = WithOptimization { flags: [true, false, true], value1: 42, value2: 100, }; println!("Unoptimized: {:?}", unoptimized); println!("Optimized: {:?}", optimized); // Bit-packing for many flags struct FlagPack { bits: u8, // 8 flags } impl FlagPack { fn set(&mut self, index: usize, value: bool) { if value { self.bits |= 1 << index; } else { self.bits &= !(1 << index); } } fn get(&self, index: usize) -> bool { (self.bits & (1 << index)) != 0 } } let mut pack = FlagPack { bits: 0 }; pack.set(0, true); pack.set(2, true); pack.set(5, true); println!("Flag pack bits: {:08b}", pack.bits); for i in 0..8 { println!("Flag {}: {}", i, pack.get(i)); } }

10. Advanced Boolean Patterns

Three-Valued Logic

#[derive(Debug, Clone, Copy, PartialEq)] enum ThreeValued { True, False, Unknown, } impl ThreeValued { fn and(self, other: ThreeValued) -> ThreeValued { match (self, other) { (ThreeValued::False, _) | (_, ThreeValued::False) => ThreeValued::False, (ThreeValued::True, ThreeValued::True) => ThreeValued::True, _ => ThreeValued::Unknown, } } fn or(self, other: ThreeValued) -> ThreeValued { match (self, other) { (ThreeValued::True, _) | (_, ThreeValued::True) => ThreeValued::True, (ThreeValued::False, ThreeValued::False) => ThreeValued::False, _ => ThreeValued::Unknown, } } fn not(self) -> ThreeValued { match self { ThreeValued::True => ThreeValued::False, ThreeValued::False => ThreeValued::True, ThreeValued::Unknown => ThreeValued::Unknown, } } } fn main() { use ThreeValued::*; let values = [True, False, Unknown]; println!("AND Truth Table:"); for &a in &values { for &b in &values { println!("{:?} AND {:?} = {:?}", a, b, a.and(b)); } } println!("\nOR Truth Table:"); for &a in &values { for &b in &values { println!("{:?} OR {:?} = {:?}", a, b, a.or(b)); } } println!("\nNOT Truth Table:"); for &a in &values { println!("NOT {:?} = {:?}", a, a.not()); } }

Lazy Boolean Evaluation

struct LazyBool<F: Fn() -> bool> { computer: F, cached: Option<bool>, } impl<F: Fn() -> bool> LazyBool<F> { fn new(computer: F) -> Self { LazyBool { computer, cached: None, } } fn evaluate(&mut self) -> bool { if let Some(value) = self.cached { value } else { let value = (self.computer)(); self.cached = Some(value); value } } } // Lazy AND that only evaluates as needed struct LazyAnd<A, B> where A: Fn() -> bool, B: Fn() -> bool, { left: A, right: B, } impl<A, B> LazyAnd<A, B> where A: Fn() -> bool, B: Fn() -> bool, { fn new(left: A, right: B) -> Self { LazyAnd { left, right } } fn evaluate(&self) -> bool { (self.left)() && (self.right)() } } fn main() { let mut counter = 0; let expensive = || { counter += 1; println!("Expensive computation running..."); true }; let mut lazy = LazyBool::new(expensive); println!("First evaluation:"); println!("Result: {}", lazy.evaluate()); println!("\nSecond evaluation (cached):"); println!("Result: {}", lazy.evaluate()); println!("\nCounter: {}", counter); // Lazy AND example let lazy_and = LazyAnd::new( || { println!("Checking first condition"); false }, || { println!("This won't be called"); true }, ); println!("Lazy AND result: {}", lazy_and.evaluate()); }

11. Common Patterns and Best Practices

Boolean Parameters

// Bad: Unclear boolean parameters fn process_data_bad(data: &[i32], sort: bool, dedup: bool, validate: bool) { // Hard to read calls: process_data_bad(&data, true, false, true) } // Better: Use enums #[derive(Debug, Clone, Copy)] enum SortOrder { Sorted, Unsorted, } #[derive(Debug, Clone, Copy)] enum Deduplicate { Enabled, Disabled, } #[derive(Debug, Clone, Copy)] enum Validation { Enabled, Disabled, } fn process_data_good(data: &[i32], sort: SortOrder, dedup: Deduplicate, validate: Validation) { match sort { SortOrder::Sorted => println!("Sorting data"), SortOrder::Unsorted => println!("Keeping original order"), } match dedup { Deduplicate::Enabled => println!("Deduplicating"), Deduplicate::Disabled => println!("Keeping duplicates"), } match validate { Validation::Enabled => println!("Validating"), Validation::Disabled => println!("Skipping validation"), } } // Alternative: Use builder pattern struct DataProcessor { sort: bool, dedup: bool, validate: bool, } impl DataProcessor { fn new() -> Self { DataProcessor { sort: false, dedup: false, validate: false, } } fn with_sort(mut self, enable: bool) -> Self { self.sort = enable; self } fn with_dedup(mut self, enable: bool) -> Self { self.dedup = enable; self } fn with_validation(mut self, enable: bool) -> Self { self.validate = enable; self } fn process(&self, data: &[i32]) { println!("Processing with: sort={}, dedup={}, validate={}", self.sort, self.dedup, self.validate); } } fn main() { let data = vec![1, 2, 3]; // Unclear // process_data_bad(&data, true, false, true); // Clear with enums process_data_good(&data, SortOrder::Sorted, Deduplicate::Disabled, Validation::Enabled); // Clear with builder DataProcessor::new() .with_sort(true) .with_validation(true) .process(&data); }

Boolean Return Types

// Clear naming for boolean functions fn is_valid_username(username: &str) -> bool { !username.is_empty() && username.len() <= 20 } fn has_permission(user_role: &str, required_role: &str) -> bool { match user_role { "admin" => true, "editor" if required_role == "editor" || required_role == "viewer" => true, "viewer" if required_role == "viewer" => true, _ => false, } } fn can_edit_document(user: &str, document_owner: &str, is_public: bool) -> bool { user == document_owner || is_public } fn main() { let username = "alice123"; if is_valid_username(username) { println!("Username is valid"); } let user = "editor"; let required = "viewer"; if has_permission(user, required) { println!("User has permission"); } let user = "bob"; let owner = "alice"; if can_edit_document(user, owner, true) { println!("Can edit document"); } }

Conclusion

Booleans in Rust are simple but powerful, forming the foundation of logical operations and control flow:

Key Takeaways

1. Type Safety: No implicit conversion to/from other types
2. Size: 1 byte in memory
3. Operations: && (AND), || (OR), ! (NOT)
4. Short-Circuiting: && and || don't evaluate second operand if not needed
5. Comparison: Produces boolean values from comparisons
6. Control Flow: Essential for if, while, match conditions
7. Bitwise Operations: &, |, ^, ! for non-short-circuiting operations

Best Practices

1. Use descriptive names for boolean variables (is_valid, has_permission, can_edit)
2. Avoid boolean parameters in function calls (use enums or builder pattern)
3. Leverage short-circuiting for efficiency and safety
4. Be explicit with boolean conversions (value != 0 instead of implicit truthiness)
5. Consider Option for three-state logic
6. Pack multiple booleans when memory is critical
7. Use boolean methods like then() and then_some() for concise code

Common Pitfalls

• Chained comparisons (a < b < c) are not allowed
• Bitwise operators (&, |) don't short-circuit
• Mixing integer and boolean requires explicit conversion
• Boolean parameters can make code unclear
• Forgetting that if conditions must be exactly bool (no truthy values)

Rust's boolean type, while simple, is designed with clarity and safety in mind, preventing entire classes of bugs common in languages with truthy/falsy coercion.