Understanding Rust Literals

Rust literals are fixed values that represent data directly in your code. They are categorized into several types based on the nature of the data they represent.

Key Concepts

• Literals: Basic data values that are written directly in the code.
• Types of Literals: Rust supports various types of literals including:
  • Integer Literals: Whole numbers that can be represented in different bases (decimal, hexadecimal, octal, binary).
  • Floating-Point Literals: Numbers with decimal points.
  • Boolean Literals: Values representing true or false.
  • Character Literals: Single characters enclosed in single quotes.
  • String Literals: Sequences of characters enclosed in double quotes.

Types of Literals

1. Integer Literals

• Can be represented in various bases:
  • Decimal (base 10): 42
  • Hexadecimal (base 16): 0x2A
  • Octal (base 8): 0o52
  • Binary (base 2): 0b101010

2. Floating-Point Literals

• Represented with a decimal point or in exponential notation:
  • Example: 3.14, 2.0e3 (which is 2000.0)

3. Boolean Literals

• Only two values: true and false.

4. Character Literals

• Represented as a single character within single quotes:
  • Example: 'A', 'z', '#'

5. String Literals

• A sequence of characters enclosed in double quotes:
  • Example: "Hello, Rust!"

Example Usage

Here’s how you might declare different types of literals in Rust:

fn main() {
    // Integer Literals
    let decimal = 100;        // Decimal
    let hex = 0x64;          // Hexadecimal
    let octal = 0o144;       // Octal
    let binary = 0b1100100;  // Binary

    // Floating-Point Literals
    let float = 10.5;        // Floating-point
    let scientific = 1.0e3;  // Exponential notation

    // Boolean Literals
    let is_rust_fun = true;

    // Character Literals
    let letter = 'R';

    // String Literals
    let greeting = "Hello, world!";

    println!("Decimal: {}, Hex: {}, Octal: {}, Binary: {}", decimal, hex, octal, binary);
    println!("Float: {}, Scientific: {}", float, scientific);
    println!("Boolean: {}", is_rust_fun);
    println!("Character: {}", letter);
    println!("String: {}", greeting);
}

Conclusion

Understanding literals in Rust is fundamental for representing data. They serve as the building blocks for more complex data structures and types in the language. By using the appropriate type of literal, you can ensure that your data is represented correctly and efficiently in your Rust programs.