1. Introduction

Rust is recognized as a systems programming language that prioritizes safety, performance, and concurrency ¹. This unique combination of features makes it a versatile choice for developing reliable and efficient software across various domains. This document serves as a concise yet comprehensive cheat sheet, providing a quick reference for the fundamental concepts of the Rust programming language. It aims to equip both newcomers and experienced programmers with the essential syntax and core principles needed to start or continue their journey with Rust.

2. Fundamental Rust Syntax

2.1. Variable Declarations

In Rust, variables are primarily declared using the let keyword ³. This keyword introduces a binding between a name and a value. A key characteristic of variables declared with let is their immutability by default ⁴. This means that once a value is assigned to a variable, that value cannot be changed. This design choice encourages safer and more predictable code by preventing unintended modifications to data ⁴.

To declare a variable whose value can be changed after initialization, the mut keyword is used in conjunction with let ³. The mut keyword explicitly makes the variable mutable, allowing its value to be reassigned later in the program's execution. This provides flexibility when state needs to be updated, but it requires a conscious decision to allow mutability ⁵.

Another way to declare variables is using the const keyword ³. Constants, unlike variables declared with let, are always immutable, and their values must be known at compile time ³. This makes them suitable for defining values that should never change throughout the program's lifetime, such as mathematical constants or configuration parameters. Furthermore, constants cannot be shadowed in the same scope ³.

Rust also supports a feature called variable shadowing ³. Shadowing allows you to declare a new variable with the same name as a previous variable within the same scope. The new variable effectively hides or "shadows" the old one. Importantly, the shadowed variable can have a different data type than the original, offering a way to reinterpret or transform a value while keeping the same identifier within a limited scope ³.

Here are some syntax examples to illustrate these concepts:

let x = 10; // Immutable variable
let mut y = 20; // Mutable variable
y = 25; // Allowed because y is mutable
const PI: f64 = 3.14159; // Constant with explicit type annotation
let z = "hello";
let z = z.len(); // Shadowing: z now holds the length (usize)

The consistent use of let for both mutable and immutable variables, differentiated by the presence of the mut keyword, promotes explicitness in managing program state. While shadowing offers flexibility, its use should be considered carefully to maintain code readability and avoid potential confusion ³.

2.2. Common Data Types

Rust provides a rich set of built-in data types that can be broadly categorized into scalar and compound types.

2.2.1. Integers

Integers in Rust are whole numbers without a fractional component. They are available in both signed (can represent negative numbers) and unsigned (can only represent non-negative numbers) variants ¹. Rust offers various integer types with different sizes, measured in bits, which determine the range of values they can hold. These sizes include 8, 16, 32, 64, and 128 bits. Additionally, there are architecture-dependent integer types, isize and usize, whose size depends on the architecture of the computer the program is running on; they are typically used for indexing collections and memory addressing ⁷.

Integer literals can be written in several formats: decimal (e.g., 98_222), hexadecimal (prefixed with 0x, e.g., 0xff), octal (prefixed with 0o, e.g., 0o77), binary (prefixed with 0b, e.g., 0b1111_0000), and byte literals (for u8 only, prefixed with b', e.g., b'A') ⁷.

The following table summarizes the built-in integer types in Rust, their sizes, and the range of values they can represent:

Rust's provision of various integer types allows for precise control over memory usage and the ability to handle different ranges of numerical data ⁷. The default integer type, when not explicitly specified, is i32 ⁷.

2.2.2. Floating-Point Numbers

Rust has two primitive types for floating-point numbers, which are numbers with decimal points: f32 (32-bit single-precision float) and f64 (64-bit double-precision float) ¹. The default floating-point type is f64 because it offers more precision and is roughly the same speed as f32 on modern CPUs ⁷. All floating-point types in Rust are signed ⁸.

2.2.3. Booleans

The bool type in Rust represents a boolean value, which can be either true or false ¹. Booleans are one byte in size and are primarily used for logical operations and conditional control flow ⁸.

2.2.4. Characters

The char type in Rust represents a single Unicode scalar value ¹. It is typically 4 bytes in size and can represent a wide range of characters, including accented letters, characters from various languages (like Chinese, Japanese, and Korean), emoji, and even zero-width spaces. Character literals are specified using single quotes (e.g., 'z', '😻') ⁸.

2.2.5. Strings

Rust handles strings through two main types: string literals (&str) and String objects ³. String literals are immutable string slices that are often hardcoded into the program. String objects, on the other hand, are growable, heap-allocated strings that own their data, allowing for modification ³.

2.2.6. Tuples

Tuples are fixed-size, ordered collections of values that can have different types ¹. They are created by enclosing a comma-separated list of values within parentheses (e.g., (1, 2.5, 'a')). Individual elements of a tuple can be accessed using destructuring or by their index (starting from 0) with a dot notation (e.g., tuple.0).

2.2.7. Arrays

Arrays in Rust are fixed-size, ordered collections where all elements must have the same data type ¹. They are defined by specifying the type of the elements followed by a semicolon and the size in square brackets (e.g., [i32; 5]). Once declared, the size of an array cannot be changed.

2.2.8. Slices

Slices are dynamically sized views into a contiguous sequence of elements, often used to borrow sections of arrays or strings ³. They do not have ownership of the data they point to and are represented by a pointer to the start of the data and a length. Slices are a fundamental part of Rust's mechanism for safe and efficient data access without transferring ownership.

Rust's strong and static typing system ensures that the type of every variable is known at compile time, which helps in catching type-related errors early in the development process ⁴. The distinction between stack-allocated data (like primitive types, arrays, and tuples) and heap-allocated data (like String) is crucial for understanding Rust's ownership and memory management model ¹¹.

2.3. Basic Operators

Rust provides a variety of operators to perform operations on values and variables. These can be categorized into arithmetic, comparison, logical, bitwise, and assignment operators ¹⁵.

Arithmetic operators include + for addition, - for subtraction, * for multiplication, / for division, and % for the remainder (modulo) operation ⁸.

Comparison operators are used to compare two values and return a boolean result: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), and <= (less than or equal to) ¹⁵.

Logical operators work with boolean values: && (logical AND), || (logical OR), and ! (logical NOT) ¹⁵.

Bitwise operators operate on the individual bits of integer types: & (bitwise AND), | (bitwise OR), ^ (bitwise XOR), ! (bitwise NOT), << (left shift), and >> (right shift) ¹⁵.

Assignment operators are used to assign values to variables. The basic assignment operator is =, and there are also compound assignment operators like +=, -=, *=, /=, and %=, which perform an arithmetic operation and then assign the result to the left operand ¹⁵.

The order in which operators are evaluated in an expression is determined by their precedence, and for operators with the same precedence, their associativity dictates the direction of evaluation ¹⁶.

The following table summarizes Rust's basic operators:

A thorough understanding of these operators and their behavior is essential for writing effective Rust programs ¹⁵.

3. Functions in Rust

3.1. Defining Functions

Functions in Rust are defined using the fn keyword ³. This keyword is followed by the name of the function, a pair of parentheses that may contain parameters, and a block of code enclosed in curly braces {} which constitutes the function body ²⁰. Function names in Rust conventionally use snake case, where all letters are lowercase and words are separated by underscores ²⁰. Functions can accept input values through parameters specified within the parentheses ²⁰.

3.2. Function Signatures

In Rust, the type of each parameter in a function's signature must be explicitly declared ²⁰. This is done by following the parameter name with a colon : and then the data type. If a function is intended to return a value, the return type must be specified after the parameter list, following an arrow -> ¹⁹. If no return type is explicitly stated, the function implicitly returns the unit type (), indicating that it does not return a meaningful value ²⁵.

3.3. Function Body

The function body, enclosed within curly braces {}, contains a sequence of statements and expressions that are executed when the function is called ²⁰. Rust is an expression-based language, meaning that most parts of the code are expressions that evaluate to a value ²⁰. Statements, on the other hand, are instructions that perform an action but do not return a value, such as variable declarations using let ²⁰. In Rust, the return value of a function is often determined by the value of the final expression in the function body. If this final expression does not end with a semicolon, its value is implicitly returned ²⁰. Functions can also return explicitly using the return keyword, which allows for returning a value at any point within the function body ²⁰.

Here are some examples of function definitions:

fn greet() { // Function with no parameters and no return value
    println!("Hello, world!");
}
fn add(x: i32, y: i32) -> i32 { // Function with two i32 parameters and returns an i32
x + y // Implicit return
}
fn is_even(n: i32) -> bool { // Function with an i32 parameter and returns a boolean
if n % 2 == 0 {
return true; // Explicit return
}
false // Implicit return
}

The requirement for explicit type annotations in function signatures is a key aspect of Rust's design, contributing to its compile-time safety ²⁰. The expression-based nature of the language allows for concise and expressive function bodies ²⁰.

4. Ownership, Borrowing, and Lifetimes

4.1. Ownership

Ownership is a central concept in Rust for managing memory without relying on garbage collection ¹¹. It ensures memory safety by establishing a set of rules that the compiler checks at compile time ¹². The core idea is that every value in Rust has a variable that owns it ¹¹. There can only be one owner of a value at a time ¹¹. When the owner goes out of scope, the value is dropped (deallocated from memory) ¹¹.

For data stored on the stack, such as primitive types, arrays, and tuples, assigning one variable to another results in a copy of the value ¹¹. This is because these types have a known size at compile time and are relatively inexpensive to duplicate. However, for data stored on the heap, like String, assigning one variable to another moves the ownership of the data from the first variable to the second ¹¹. After the move, the original variable is no longer valid and cannot be used ¹¹.

If you need to make a copy of heap-allocated data, you can use the clone() method, which is part of the Clone trait ¹¹. Cloning creates a deep copy of the data on the heap, which can be more expensive in terms of performance than a move operation ¹¹.

The ownership system ensures that there is always a single point of responsibility for managing memory, preventing issues like dangling pointers and double frees ¹¹.

4.2. Borrowing

Borrowing allows you to access data without taking ownership ². This is done using references, which are like pointers that point to a value. Rust has two types of references: immutable references and mutable references ².

Immutable references are created using & followed by the value. They allow you to read the data but not modify it ². You can have multiple immutable references to the same data at the same time ².

Mutable references are created using &mut followed by the value. They allow you to modify the data ². However, there is a strict rule: you can have only one mutable reference to a particular piece of data at any given time ². This rule prevents data races in concurrent programming ².

The rules of borrowing are: you can have either one mutable reference or any number of immutable references to a value, but not both at the same time ². Also, all references must always be valid, meaning they must point to data that still exists ². The borrow checker, a component of the Rust compiler, enforces these rules at compile time ².

4.3. Lifetimes

Lifetimes are a mechanism in Rust to ensure that references are valid as long as they are used, especially when dealing with references across function boundaries ². A reference's lifetime is the scope for which the reference is guaranteed to be valid ³³. The borrow checker uses this information to prevent dangling references, which occur when a reference points to memory that has been deallocated ².

Lifetime annotations use an apostrophe ' followed by a name (e.g., 'a) and are added to function signatures and struct definitions to explicitly specify the relationships between the lifetimes of references ³⁴. For example, a function that takes two references and returns one of them might use lifetime annotations to indicate that the returned reference will be valid as long as the input references are valid ³⁴.

In many common cases, the Rust compiler can automatically infer lifetimes through a process called lifetime elision ³⁵. This reduces the need for explicit annotations, making the code cleaner. However, in more complex scenarios, especially those involving multiple references with unclear lifetime relationships, explicit annotations are necessary to guide the compiler ³⁴.

Example of a function with lifetime annotations:

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

Here, the lifetime 'a specifies that the references x and y and the returned reference must all have the same lifetime.

5. Structs and Enums

5.1. Structs

Structs (short for structures) are custom data types in Rust that allow you to group together named fields of potentially different types ¹. They are defined using the struct keyword followed by the struct name and a block of curly braces containing the field definitions (name: type) ¹.

struct Person {
    name: String,
    age: u8,
    is_employed: bool,
}

Instances of a struct are created by specifying the struct name followed by curly braces and providing values for each field using the field_name: value syntax ³⁸.

let person = Person {
    name: String::from("Alice"),
    age: 30,
    is_employed: true,
};

Fields of a struct instance can be accessed using dot notation (.) ³⁸. For example, person.name would access the name field of the person instance.

Rust also supports tuple structs, which are similar to structs but their fields are unnamed and are accessed by index ³⁹.

struct Color(u8, u8, u8);
let red = Color(255, 0, 0);
let red_value = red.0; // Accessing the first field

Unit-like structs are structs with no fields and are often used in generics ³⁹.

struct Marker;

Rust provides convenient ways to instantiate structs, such as field init shorthand (if a field has the same name as a local variable) and struct update syntax (..) to create a new instance based on an existing one ³⁹.

5.2. Enums

Enums (short for enumerations) are custom data types that can hold one of several possible variants ¹. They are defined using the enum keyword followed by the enum name and a block of curly braces containing the variants ¹.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

Enum variants can be unit-like (like Quit), tuple-like (like Write), or struct-like (like Move and ChangeColor), allowing them to hold associated data ⁴³.

Instances of enums are created using the enum name followed by the scope resolution operator :: and the variant name, along with any associated data if the variant requires it ⁴⁴.

let quit_message = Message::Quit;
let move_message = Message::Move { x: 10, y: 20 };
let write_message = Message::Write(String::from("hello"));
let color_change_message = Message::ChangeColor(255, 0, 0);

match expressions are commonly used to handle different enum variants ⁴⁶. The standard library provides important enums like Option<T> (for optional values) and Result<T, E> (for error handling) ⁴⁷.

Conclusions

Rust's design emphasizes memory safety, performance, and concurrency, making it a powerful language for a wide range of applications. The fundamental syntax for variable declarations, with its default immutability and explicit mutability, promotes safer coding practices. Rust's rich set of data types, including scalar and compound types, provides developers with the tools to model data effectively, with a clear distinction between stack and heap allocation influencing memory management. The ownership, borrowing, and lifetime system, while initially challenging, is crucial for achieving memory safety without garbage collection, enabling efficient and reliable code. Structs and enums allow for the creation of custom data types that can represent complex data structures and states in a type-safe manner. These core concepts form the foundation for writing robust and performant Rust applications.