Introduction to Constants in Rust

Constants in Rust are values that are bound to a name and cannot be changed. They represent a fundamental concept in programming for defining values that remain the same throughout a program's execution. Rust's approach to constants emphasizes compile-time evaluation, type safety, and clear semantics.

Key Concepts

• Immutable: Constants can never be modified
• Compile-time: Evaluated at compile time
• Global Scope: Can be declared in any scope
• Type Annotation: Always require explicit type annotations
• No Fixed Address: Inlined at each usage location
• Naming Convention: Screaming snake case (e.g., MAX_POINTS)

1. Basic Constants

Declaring Constants

// Basic constant declaration const MAX_POINTS: u32 = 100_000; const PI: f64 = 3.14159265359; const APP_NAME: &str = "My Rust Application"; const DEBUG_MODE: bool = true; fn main() { // Using constants println!("Max points: {}", MAX_POINTS); println!("PI: {}", PI); println!("App name: {}", APP_NAME); println!("Debug mode: {}", DEBUG_MODE); // Constants can be used in expressions let area = PI * 5.0 * 5.0; let half_max = MAX_POINTS / 2; println!("Area: {}", area); println!("Half max: {}", half_max); }

Constants in Different Scopes

// Global scope constant const GLOBAL_CONST: i32 = 42; fn main() { println!("Global: {}", GLOBAL_CONST); // Constant in function scope const LOCAL_CONST: i32 = 100; println!("Local: {}", LOCAL_CONST); // Constant in block scope { const BLOCK_CONST: i32 = 200; println!("Block: {}", BLOCK_CONST); } // println!("{}", BLOCK_CONST); // Error: not in scope // Constants can shadow each other const SHADOW: i32 = 1; println!("Shadow 1: {}", SHADOW); { const SHADOW: i32 = 2; println!("Shadow 2: {}", SHADOW); } println!("Shadow 3: {}", SHADOW); }

2. Constant Evaluation

Compile-Time Evaluation

// Constants must be evaluable at compile time const SECONDS_IN_HOUR: u32 = 60 * 60; const SECONDS_IN_DAY: u32 = SECONDS_IN_HOUR * 24; const SECONDS_IN_WEEK: u32 = SECONDS_IN_DAY * 7; // Complex constant expressions const ARRAY_SIZE: usize = 5 * 4 * 3 * 2; const LARGE_NUMBER: i64 = 2_i64.pow(20); const MASK: u8 = 0b1010_1010; const HEX_MASK: u32 = 0xFF00FF00; fn main() { println!("Seconds in hour: {}", SECONDS_IN_HOUR); println!("Seconds in day: {}", SECONDS_IN_DAY); println!("Seconds in week: {}", SECONDS_IN_WEEK); println!("Array size: {}", ARRAY_SIZE); println!("Large number: {}", LARGE_NUMBER); println!("Mask: {:b}", MASK); // Constants in array sizes let array: [i32; ARRAY_SIZE] = [0; ARRAY_SIZE]; println!("Array length: {}", array.len()); }

Const Functions

// Const functions can be called at compile time const fn multiply(a: i32, b: i32) -> i32 { a * b } const fn factorial(n: u64) -> u64 { let mut result = 1; let mut i = 1; // Limited control flow in const functions while i <= n { result *= i; i += 1; } result } const fn power(base: u64, exp: u32) -> u64 { let mut result = 1; let mut i = 0; while i < exp { result *= base; i += 1; } result } // Using const functions in constants const MULTIPLIED: i32 = multiply(5, 6); const FACTORIAL_5: u64 = factorial(5); const POWER_2_10: u64 = power(2, 10); fn main() { println!("Multiplied: {}", MULTIPLIED); println!("Factorial of 5: {}", FACTORIAL_5); println!("2^10: {}", POWER_2_10); // Const functions can also be called at runtime let runtime_val = multiply(10, 20); println!("Runtime multiply: {}", runtime_val); }

3. Constant vs Static

Comparing Constants and Statics

// Constant - inlined at each usage const CONST_VAL: i32 = 42; // Static - single memory location static STATIC_VAL: i32 = 42; // Mutable static (requires unsafe) static mut MUTABLE_STATIC: i32 = 0; // Static with complex type static CONFIG: Config = Config { name: "default", version: 1, }; struct Config { name: &'static str, version: u32, } fn main() { // Constants are inlined println!("Constant: {}", CONST_VAL); println!("Constant address: {:p}", &CONST_VAL); // Each usage may have different address // Statics have fixed address println!("Static: {}", STATIC_VAL); println!("Static address: {:p}", &STATIC_VAL); // Multiple references to static point to same location let ref1 = &STATIC_VAL; let ref2 = &STATIC_VAL; println!("ref1: {:p}, ref2: {:p}", ref1, ref2); // Mutable statics require unsafe unsafe { MUTABLE_STATIC += 1; println!("Mutable static: {}", MUTABLE_STATIC); } // Static with complex type println!("Config: {} v{}", CONFIG.name, CONFIG.version); } // Key differences: // - Constants: Inlined, no fixed memory location // - Statics: Single memory location, can be mutable (unsafe) // - Constants: Only primitives and const functions // - Statics: Can have destructors, can be mutable

When to Use Constants vs Statics

// Use constants for: // - Mathematical constants const PI: f64 = 3.141592653589793; const E: f64 = 2.718281828459045; // - Configuration values const MAX_CONNECTIONS: u32 = 100; const TIMEOUT_SECONDS: u64 = 30; const BUFFER_SIZE: usize = 1024; // - Magic numbers with meaningful names const HTTP_OK: u16 = 200; const HTTP_NOT_FOUND: u16 = 404; const HTTP_INTERNAL_ERROR: u16 = 500; // Use statics for: // - Large data that shouldn't be duplicated static LARGE_LOOKUP_TABLE: [u32; 1024] = [0; 1024]; // - Global state (with Mutex for thread safety) use std::sync::Mutex; static GLOBAL_COUNTER: Mutex<u32> = Mutex::new(0); // - Lazy initialization patterns static LAZY_DATA: once_cell::sync::Lazy<Vec<String>> = once_cell::sync::Lazy::new(|| { vec!["data1".to_string(), "data2".to_string()] }); fn main() { // Using constants println!("PI: {}", PI); println!("Buffer size: {} bytes", BUFFER_SIZE); // Using statics println!("Lookup table first element: {}", LARGE_LOOKUP_TABLE[0]); // Thread-safe static mutation let mut counter = GLOBAL_COUNTER.lock().unwrap(); *counter += 1; println!("Global counter: {}", *counter); // Lazy static println!("Lazy data: {:?}", *LAZY_DATA); }

4. Constant Expressions

Allowed Operations in Constants

// Basic arithmetic const SUM: i32 = 10 + 20; const DIFFERENCE: i32 = 100 - 30; const PRODUCT: i32 = 5 * 6; const QUOTIENT: i32 = 100 / 5; const REMAINDER: i32 = 17 % 5; const NEGATED: i32 = -42; // Bitwise operations const BIT_AND: u8 = 0b1010 & 0b1100; // 0b1000 const BIT_OR: u8 = 0b1010 | 0b1100; // 0b1110 const BIT_XOR: u8 = 0b1010 ^ 0b1100; // 0b0110 const BIT_SHL: u8 = 0b0001 << 3; // 0b1000 const BIT_SHR: u8 = 0b1000 >> 2; // 0b0010 const BIT_NOT: u8 = !0b1010; // Bitwise complement // Logical operations (for bool) const TRUE_VAL: bool = true; const FALSE_VAL: bool = false; const AND_RESULT: bool = true && false; const OR_RESULT: bool = true || false; const NOT_RESULT: bool = !true; // Comparisons const IS_EQUAL: bool = 42 == 42; const IS_NOT_EQUAL: bool = 42 != 43; const IS_GREATER: bool = 100 > 50; const IS_LESS: bool = 50 < 100; const IS_GREATER_EQ: bool = 50 >= 50; const IS_LESS_EQ: bool = 50 <= 100; // Type casting const CASTED: i64 = 42_i32 as i64; const CHAR_FROM_U8: char = 65 as char; // 'A' const BOOL_FROM_INT: bool = 1 != 0; // Not direct cast, but expression fn main() { println!("Sum: {}", SUM); println!("Bit AND: {:b}", BIT_AND); println!("AND result: {}", AND_RESULT); println!("Is equal: {}", IS_EQUAL); println!("Casted: {}", CASTED); }

Complex Constant Expressions

// Arrays in constants const NUMBERS: [i32; 5] = [1, 2, 3, 4, 5]; const ZEROS: [i32; 10] = [0; 10]; // Tuples in constants const POINT: (i32, i32) = (10, 20); const RGB: (u8, u8, u8) = (255, 128, 0); // Strings in constants const GREETING: &str = "Hello, world!"; const EMPTY_STRING: &str = ""; // Option in constants const SOME_VALUE: Option<i32> = Some(42); const NONE_VALUE: Option<i32> = None; // Result in constants const OK_RESULT: Result<i32, &str> = Ok(42); const ERR_RESULT: Result<i32, &str> = Err("error"); // Complex expressions const COMPUTED_ARRAY: [i32; 3] = [ 1 + 2, 3 * 4, 10 - 5, ]; const NESTED_TUPLE: (i32, (i32, i32)) = (1, (2, 3)); fn main() { println!("Numbers: {:?}", NUMBERS); println!("Point: {:?}", POINT); println!("Greeting: {}", GREETING); println!("Some value: {:?}", SOME_VALUE); println!("Computed array: {:?}", COMPUTED_ARRAY); println!("Nested tuple: {:?}", NESTED_TUPLE); // Using constants in patterns match 42 { SOME_VALUE => println!("Matched 42!"), _ => println!("No match"), } }

5. Constants in Different Contexts

Constants in Enums

enum HttpStatus { Ok = 200, NotFound = 404, InternalError = 500, } // Constants for enum variants const OK_CODE: u16 = HttpStatus::Ok as u16; const NOT_FOUND_CODE: u16 = HttpStatus::NotFound as u16; // Enum with associated constants enum Planet { Mercury, Venus, Earth, Mars, } impl Planet { // Associated constants const COUNT: usize = 4; const NAMES: [&'static str; 4] = ["Mercury", "Venus", "Earth", "Mars"]; fn gravity(&self) -> f64 { match self { Planet::Mercury => 3.7, Planet::Venus => 8.9, Planet::Earth => 9.8, Planet::Mars => 3.7, } } } fn main() { println!("OK code: {}", OK_CODE); println!("Not found: {}", NOT_FOUND_CODE); println!("Number of planets: {}", Planet::COUNT); println!("Planet names: {:?}", Planet::NAMES); let earth = Planet::Earth; println!("Earth gravity: {} m/s²", earth.gravity()); }

Constants in Structs

struct Circle { radius: f64, } impl Circle { // Associated constants const PI: f64 = 3.141592653589793; const DEFAULT_RADIUS: f64 = 1.0; const UNITS: &'static str = "meters"; fn new(radius: f64) -> Self { Circle { radius } } fn area(&self) -> f64 { Circle::PI * self.radius * self.radius } fn default() -> Self { Circle { radius: Circle::DEFAULT_RADIUS, } } } // Constants in struct fields (not directly, but as defaults) struct Config { host: &'static str, port: u16, timeout: u64, } impl Config { const DEFAULT_HOST: &'static str = "localhost"; const DEFAULT_PORT: u16 = 8080; const DEFAULT_TIMEOUT: u64 = 30; fn default() -> Self { Config { host: Config::DEFAULT_HOST, port: Config::DEFAULT_PORT, timeout: Config::DEFAULT_TIMEOUT, } } } fn main() { println!("PI: {}", Circle::PI); println!("Units: {}", Circle::UNITS); let circle = Circle::default(); println!("Default circle area: {}", circle.area()); let config = Config::default(); println!("Config: {}:{} (timeout: {}s)", config.host, config.port, config.timeout); }

Constants in Traits

trait MathConstants { const PI: f64; const E: f64; const PHI: f64; } impl MathConstants for f64 { const PI: f64 = 3.141592653589793; const E: f64 = 2.718281828459045; const PHI: f64 = 1.618033988749895; } impl MathConstants for f32 { const PI: f32 = 3.1415927; const E: f32 = 2.7182818; const PHI: f32 = 1.618034; } trait WithDefault { const DEFAULT: Self; } impl WithDefault for i32 { const DEFAULT: Self = 0; } impl WithDefault for String { const DEFAULT: Self = String::new(); } impl WithDefault for bool { const DEFAULT: Self = false; } fn main() { println!("f64 PI: {}", f64::PI); println!("f32 PI: {}", f32::PI); println!("i32 default: {}", i32::DEFAULT); println!("bool default: {}", bool::DEFAULT); }

6. Advanced Constant Patterns

Constant Generic Parameters

// Using constants in generic parameters struct Array<T, const N: usize> { data: [T; N], } impl<T, const N: usize> Array<T, N> { fn new(data: [T; N]) -> Self { Array { data } } fn len(&self) -> usize { N } } // Const generics with expressions fn sum_array<const N: usize>(arr: [i32; N]) -> i32 { let mut sum = 0; for i in 0..N { sum += arr[i]; } sum } // Const generics with defaults struct Buffer<const SIZE: usize = 1024> { data: [u8; SIZE], pos: usize, } impl<const SIZE: usize> Buffer<SIZE> { fn new() -> Self { Buffer { data: [0; SIZE], pos: 0, } } } fn main() { let arr = Array::new([1, 2, 3, 4, 5]); println!("Array length: {}", arr.len()); let sum = sum_array([1, 2, 3, 4, 5]); println!("Sum: {}", sum); // Using const generics with different sizes let buffer1: Buffer<512> = Buffer::new(); let buffer2: Buffer<2048> = Buffer::new(); let buffer3: Buffer = Buffer::new(); // Uses default 1024 println!("Buffer sizes: {}, {}, {}", std::mem::size_of_val(&buffer1), std::mem::size_of_val(&buffer2), std::mem::size_of_val(&buffer3)); }

Conditional Constants with cfg

// Platform-specific constants #[cfg(target_os = "windows")] const LINE_ENDING: &str = "\r\n"; #[cfg(target_os = "linux")] const LINE_ENDING: &str = "\n"; #[cfg(target_os = "macos")] const LINE_ENDING: &str = "\r"; // Feature-dependent constants #[cfg(feature = "debug")] const LOG_LEVEL: &str = "debug"; #[cfg(not(feature = "debug"))] const LOG_LEVEL: &str = "info"; // Architecture-specific constants #[cfg(target_arch = "x86_64")] const ARCH: &str = "x86_64"; #[cfg(target_arch = "aarch64")] const ARCH: &str = "ARM64"; // Environment-dependent constants #[cfg(debug_assertions)] const BUILD_TYPE: &str = "debug"; #[cfg(not(debug_assertions))] const BUILD_TYPE: &str = "release"; fn main() { println!("Line ending: {:?}", LINE_ENDING); println!("Log level: {}", LOG_LEVEL); println!("Architecture: {}", ARCH); println!("Build type: {}", BUILD_TYPE); }

Recursive Constants

// Recursive constants (careful with infinite recursion) const fn factorial(n: u64) -> u64 { match n { 0 | 1 => 1, _ => n * factorial(n - 1), } } const fn fibonacci(n: u64) -> u64 { if n <= 1 { n } else { fibonacci(n - 1) + fibonacci(n - 2) } } // Using recursive const functions const FACT_10: u64 = factorial(10); const FIB_10: u64 = fibonacci(10); fn main() { println!("Factorial of 10: {}", FACT_10); println!("Fibonacci of 10: {}", FIB_10); // These are computed at compile time, no runtime cost println!("Factorial of 20: {}", factorial(20)); }

7. Constants in Pattern Matching

Using Constants in Patterns

// Constants in match patterns const RED: u8 = 0; const GREEN: u8 = 1; const BLUE: u8 = 2; const ALPHA: u8 = 3; fn get_color_name(index: u8) -> &'static str { match index { RED => "Red", GREEN => "Green", BLUE => "Blue", ALPHA => "Alpha", _ => "Unknown", } } // Constants in range patterns const MIN_VALUE: i32 = 0; const MAX_VALUE: i32 = 100; const THRESHOLD: i32 = 50; fn categorize(value: i32) -> &'static str { match value { MIN_VALUE..=THRESHOLD => "Low", THRESHOLD + 1..=MAX_VALUE => "High", _ => "Out of range", } } // Constants in if let patterns const SOME_CONST: Option<i32> = Some(42); fn main() { println!("Color at 1: {}", get_color_name(1)); println!("Color at 3: {}", get_color_name(3)); println!("Categorize 25: {}", categorize(25)); println!("Categorize 75: {}", categorize(75)); let value = Some(42); if let SOME_CONST = value { println!("Matched the constant!"); } }

8. Performance Considerations

Inlining Behavior

// Constants are inlined at compile time const INLINED_VALUE: i32 = 42; // This function will have the constant inlined fn use_constant() -> i32 { INLINED_VALUE // Replaced with 42 at compile time } // Static has a single memory location static STATIC_VALUE: i32 = 42; fn use_static() -> i32 { STATIC_VALUE // Loads from memory location } // Compile-time evaluation const COMPLEX_CONST: i32 = { let mut result = 0; let mut i = 0; while i < 10 { result += i; i += 1; } result }; fn main() { // These look similar but have different runtime behavior println!("Constant: {}", use_constant()); println!("Static: {}", use_static()); // The complex const is fully computed at compile time println!("Complex const: {}", COMPLEX_CONST); // Assembly difference (conceptual): // Constant: mov eax, 42 // Static: mov eax, [rip + __STATIC_VALUE] }

Memory Usage

// Constants don't occupy memory at runtime (inlined) const LARGE_CONSTANT: [u8; 1024] = [0; 1024]; // Static occupies memory throughout program lifetime static LARGE_STATIC: [u8; 1024] = [0; 1024]; // Multiple uses of constant - each usage inlines the value fn multiple_uses_constant() { // Each of these might create a new copy at the usage site let a = LARGE_CONSTANT[0]; let b = LARGE_CONSTANT[512]; let c = LARGE_CONSTANT[1023]; println!("{}, {}, {}", a, b, c); } // Multiple uses of static - all refer to same memory fn multiple_uses_static() { // All refer to the same memory location let a = LARGE_STATIC[0]; let b = LARGE_STATIC[512]; let c = LARGE_STATIC[1023]; println!("{}, {}, {}", a, b, c); } fn main() { // For small values, inlining is efficient // For large values, consider using static to avoid duplication multiple_uses_constant(); multiple_uses_static(); }

9. Best Practices and Patterns

Naming Conventions

// Constants use SCREAMING_SNAKE_CASE const MAX_CONNECTIONS: u32 = 100; const DEFAULT_TIMEOUT_SECONDS: u64 = 30; const API_BASE_URL: &str = "https://api.example.com/v1"; // Type aliases for complex constant types type ErrorCode = u32; const ERROR_NOT_FOUND: ErrorCode = 404; const ERROR_UNAUTHORIZED: ErrorCode = 401; // Group related constants mod http { pub const OK: u16 = 200; pub const CREATED: u16 = 201; pub const ACCEPTED: u16 = 202; pub const BAD_REQUEST: u16 = 400; pub const UNAUTHORIZED: u16 = 401; pub const NOT_FOUND: u16 = 404; } mod limits { pub const MAX_NAME_LENGTH: usize = 100; pub const MAX_DESCRIPTION_LENGTH: usize = 1000; pub const MAX_ITEMS_PER_PAGE: usize = 50; } fn main() { println!("HTTP OK: {}", http::OK); println!("Max name length: {}", limits::MAX_NAME_LENGTH); }

Configuration Pattern

// Configuration constants module mod config { // Environment-based configuration pub const APP_NAME: &str = env!("CARGO_PKG_NAME"); pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION"); // Feature flags as constants pub const FEATURE_AUTH_ENABLED: bool = true; pub const FEATURE_LOGGING_ENABLED: bool = cfg!(feature = "logging"); // Database configuration pub const DB_MAX_CONNECTIONS: u32 = 10; pub const DB_TIMEOUT_SECONDS: u64 = 5; // API configuration pub const API_RATE_LIMIT: u32 = 100; pub const API_TIMEOUT_SECONDS: u64 = 30; // Feature-dependent defaults #[cfg(debug_assertions)] pub const LOG_LEVEL: &str = "debug"; #[cfg(not(debug_assertions))] pub const LOG_LEVEL: &str = "info"; } // Usage in application fn main() { println!("Starting {} v{}", config::APP_NAME, config::APP_VERSION); println!("Log level: {}", config::LOG_LEVEL); if config::FEATURE_AUTH_ENABLED { println!("Authentication enabled"); } println!("DB connections: {}", config::DB_MAX_CONNECTIONS); }

Magic Number Replacement

// Bad: Magic numbers fn calculate_discount_bad(price: f64, customer_type: u8) -> f64 { if customer_type == 1 { price * 0.9 // What is 1? What is 0.9? } else if customer_type == 2 { price * 0.85 // Hard to understand and maintain } else { price } } // Good: Named constants const CUSTOMER_TYPE_REGULAR: u8 = 1; const CUSTOMER_TYPE_PREMIUM: u8 = 2; const CUSTOMER_TYPE_VIP: u8 = 3; const DISCOUNT_REGULAR: f64 = 0.90; const DISCOUNT_PREMIUM: f64 = 0.85; const DISCOUNT_VIP: f64 = 0.80; fn calculate_discount_good(price: f64, customer_type: u8) -> f64 { match customer_type { CUSTOMER_TYPE_REGULAR => price * DISCOUNT_REGULAR, CUSTOMER_TYPE_PREMIUM => price * DISCOUNT_PREMIUM, CUSTOMER_TYPE_VIP => price * DISCOUNT_VIP, _ => price, } } // Even better: Use enum #[derive(Debug, Clone, Copy)] enum CustomerTier { Regular, Premium, VIP, } impl CustomerTier { const fn discount(&self) -> f64 { match self { CustomerTier::Regular => 0.90, CustomerTier::Premium => 0.85, CustomerTier::VIP => 0.80, } } } fn main() { let price = 100.0; println!("Regular: {}", calculate_discount_good(price, CUSTOMER_TYPE_REGULAR)); println!("Premium: {}", calculate_discount_good(price, CUSTOMER_TYPE_PREMIUM)); let tier = CustomerTier::VIP; println!("VIP: {}", price * tier.discount()); }

10. Common Pitfalls and Solutions

Type Mismatches

// Wrong: Type mismatch // const BAD_CONST: u8 = 300; // Error: 300 doesn't fit in u8 // Correct: Use appropriate type const GOOD_CONST: u16 = 300; // Wrong: No type annotation // const BAD = 42; // Error: need type annotation // Correct: Always annotate const GOOD: i32 = 42; // Wrong: Runtime computation // const BAD: i32 = std::time::SystemTime::now() // .duration_since(std::time::UNIX_EPOCH) // .unwrap() // .as_secs() as i32; // Error: not constant // Correct: Only compile-time operations const GOOD_COMPUTED: i32 = 42 * 2 + 10; fn main() { println!("Good const: {}", GOOD); println!("Good computed: {}", GOOD_COMPUTED); }

Shadowing and Visibility

// Module with private constant mod inner { const PRIVATE_CONST: i32 = 42; // Private by default pub const PUBLIC_CONST: i32 = 100; // Public // Public constant with private type is impossible // struct PrivateType; // pub const BAD: PrivateType = PrivateType; // Error } // Constant shadowing const SHADOW: i32 = 1; fn shadow_example() { const SHADOW: i32 = 2; // Shadows outer constant println!("Inner shadow: {}", SHADOW); { const SHADOW: i32 = 3; // Shadows again println!("Block shadow: {}", SHADOW); } println!("Back to function shadow: {}", SHADOW); } fn main() { println!("Outer shadow: {}", SHADOW); shadow_example(); println!("Back to outer: {}", SHADOW); // println!("{}", inner::PRIVATE_CONST); // Error: private println!("Public const: {}", inner::PUBLIC_CONST); }

Circular Dependencies

// Bad: Circular dependency // const A: i32 = B + 1; // const B: i32 = A - 1; // Error: circular dependency // Good: Define in proper order const BASE: i32 = 10; const A: i32 = BASE * 2; const B: i32 = A - 5; // Complex but valid dependencies const fn compute_x() -> i32 { 5 } const X: i32 = compute_x(); const Y: i32 = X * 2; const Z: i32 = Y + X; fn main() { println!("A: {}, B: {}", A, B); println!("X: {}, Y: {}, Z: {}", X, Y, Z); }

Conclusion

Constants in Rust provide a powerful mechanism for defining immutable, compile-time evaluated values:

Key Takeaways

1. Immutability: Constants are always immutable
2. Compile-time: Evaluated at compile time
3. Type Safety: Require explicit type annotations
4. Inlining: Inlined at each usage location
5. Global Scope: Can be defined in any scope
6. Naming Convention: Use SCREAMING_SNAKE_CASE

When to Use Constants

• Mathematical constants (PI, E, etc.)
• Configuration values (timeouts, limits, etc.)
• Magic number replacement (HTTP status codes, error codes)
• Array sizes and compile-time known values
• Default values for types
• Feature flags and compile-time configuration

Best Practices

1. Always annotate types - Constants require explicit types
2. Use screaming snake case - Follow Rust naming conventions
3. Group related constants - Use modules for organization
4. Prefer constants over magic numbers - Improve code readability
5. Consider static for large data - Avoid duplication for large constants
6. Use const functions - For complex compile-time computations
7. Document constants - Explain what they represent and why

Constants vs Statics

Feature	Constants	Statics
Memory	Inlined	Single location
Mutability	Never	Can be mutable (unsafe)
Type	Any type	Any type
Initialization	Compile-time	Compile-time
Drop	No drop	Can have drop
Address	No fixed address	Fixed address

Constants are fundamental to writing clear, maintainable Rust code. They help eliminate magic numbers, centralize configuration, and enable compile-time optimizations while maintaining type safety and clarity.