Rust Literals

Rust literals are fixed values that represent data directly in your code. Understanding literals is essential for working with different data types in Rust. This guide covers the main points about literals in Rust.

Key Concepts

• Definition: A literal is a constant value that is directly written in the code. It can represent various data types.
• Types of Literals:
  • Integer Literals: Represent whole numbers.
  • Floating-Point Literals: Represent numbers with fractions.
  • Boolean Literals: Represent truth values (true or false).
  • Character Literals: Represent a single character.
  • String Literals: Represent a sequence of characters.

Integer Literals

Integer literals can be written in various bases:

• Decimal (base 10): 42
• Hexadecimal (base 16): 0x2A
• Octal (base 8): 0o52
• Binary (base 2): 0b101010

Example:

let decimal = 42; // Decimal
let hex = 0x2A;   // Hexadecimal
let octal = 0o52; // Octal
let binary = 0b101010; // Binary

Floating-Point Literals

Floating-point literals represent numbers with a fractional part. There are two types in Rust:

• f32: 32-bit floating point
• f64: 64-bit floating point (default type)

Example:

let x = 2.0; // f64
let y: f32 = 3.0; // f32

Boolean Literals

Boolean literals represent truth values with two possible literals:

• true
• false

Example:

let is_rust_fun = true;
let is_rust_hard = false;

Character Literals

Character literals represent a single character and are enclosed in single quotes. They can include Unicode characters.

Example:

let letter = 'A';
let emoji = '😀';

String Literals

String literals represent a sequence of characters and are enclosed in double quotes. Strings are immutable and can be used directly in code.

Example:

let greeting = "Hello, Rust!";

Conclusion

Literals in Rust are a fundamental concept that allows you to define constant values directly in your code. By understanding the different types of literals, you can effectively work with various data types in Rust.