This Rust cheatsheet provides a quick reference to essential Rust concepts, syntax, and functionalities. Whether you're a beginner or an experienced developer, this guide will help you quickly look up common Rust patterns and features.


1. Basic Syntax

Hello, World!


fn main() {
    println!("Hello, world!");
}

Variables

  • Immutable Variables (default):

let x = 5;
  • Mutable Variables:

let mut x = 5;
x = 6;
  • Constants:

const MAX_POINTS: u32 = 100_000;

Data Types

  • Scalar Types: i32, u32, f64, bool, char
  • Compound Types: Tuples, Arrays

let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;

let a = [1, 2, 3, 4, 5];

2. Control Flow

If/Else


let number = 6;

if number % 4 == 0 {
    println!("Number is divisible by 4");
} else if number % 3 == 0 {
    println!("Number is divisible by 3");
} else {
    println!("Number is not divisible by 4 or 3");
}

Loops

  • Infinite Loop:

loop {
    println!("Loop forever!");
}
  • While Loop:

let mut number = 3;

while number != 0 {
    println!("{}!", number);

    number -= 1;
}
  • For Loop:

let a = [10, 20, 30, 40, 50];

for element in a.iter() {
    println!("The value is: {}", element);
}

3. Functions

Basic Function


fn main() {
    println!("The result is: {}", add(5, 3));
}

fn add(x: i32, y: i32) -> i32 {
    x + y
}

Return Values

Functions return the last expression without a semicolon:


fn five() -> i32 {
    5
}

4. Ownership and Borrowing

Ownership

  • Move Semantics:

let s1 = String::from("hello");
let s2 = s1; // s1 is now invalid
  • Clone:

let s1 = String::from("hello");
let s2 = s1.clone(); // Deep copy

Borrowing

  • Immutable Borrowing:

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}
  • Mutable Borrowing:

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
}

fn change(s: &mut String) {
    s.push_str(", world");
}

Slices


let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];

5. Structs

Defining a Struct


struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

Instantiating a Struct


let user1 = User {
    username: String::from("someusername"),
    email: String::from("someone@example.com"),
    sign_in_count: 1,
    active: true,
};

Struct Update Syntax


let user2 = User {
    email: String::from("another@example.com"),
    ..user1
};

Tuple Structs


struct Color(i32, i32, i32);
let black = Color(0, 0, 0);

6. Enums

Defining an Enum


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

Using Enums


let m = Message::Write(String::from("hello"));

match m {
    Message::Quit => println!("Quit"),
    Message::Move { x, y } => println!("Move to x: {}, y: {}", x, y),
    Message::Write(text) => println!("Text: {}", text),
    Message::ChangeColor(r, g, b) => println!("Change color to red: {}, green: {}, blue: {}", r, g, b),
}

7. Error Handling

Panic!


fn main() {
    panic!("Crash and burn");
}

Result and match


use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let f = File::open("hello.txt");

    let f = match f {
        Ok(file) => file,
        Err(ref error) if error.kind() == ErrorKind::NotFound => {
            match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            }
        },
        Err(error) => {
            panic!("Problem opening the file: {:?}", error)
        },
    };
}

Using unwrap and expect


let f = File::open("hello.txt").unwrap();
let f = File::open("hello.txt").expect("Failed to open hello.txt");

8. Traits

Defining a Trait


pub trait Summary {
    fn summarize(&self) -> String;
}

Implementing a Trait


struct Article {
    title: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}, {}", self.title, self.content)
    }
}

Default Trait Methods


pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

Trait Bounds


fn notify(item: T) {
    println!("Breaking news! {}", item.summarize());
}

9. Lifetimes

Basic Lifetime Annotation


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

Structs with Lifetimes


struct ImportantExcerpt<'a> {
    part: &'a str,
}

10. Collections

Vectors


let mut v = Vec::new();
v.push(5);
v.push(6);
v.push(7);

let third = &v[2];

Hash Maps


use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

Iterating Over Collections


for i in &v {
    println!("{}", i);
}

for (key, value) in &scores {
    println!("{}: {}", key, value);
}

11. Concurrency

Threads


use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Channels


use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

12. Modules and Crates

Creating Modules


mod network {
    pub fn connect() {
        println!("connected");
    }
}

Using Modules


fn main() {
    network::connect();
}

External Crates

In Cargo.toml:


[dependencies]
rand = "0.8.3"

In your code:


use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    let n: u8 =

 rng.gen();
    println!("Random number: {}", n);
}

13. Common Macros

println!


println!("Hello, {}!", "world");

vec!


let v = vec![1, 2, 3];

format!


let s = format!("{} {}", "Hello", "world");

14. Cargo

Creating a New Project


cargo new my_project
cd my_project

Building and Running


cargo build
cargo run
cargo check

Adding Dependencies

In Cargo.toml:


[dependencies]
serde = "1.0"
serde_json = "1.0"

Running Tests


cargo test

15. Testing

Writing Tests


#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    fn another() {
        panic!("This test will fail");
    }
}

Running Tests


cargo test

16. Error Handling

Result and Option


fn divide(dividend: f64, divisor: f64) -> Result {
    if divisor == 0.0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(dividend / divisor)
    }
}

Unwrap and Expect


let file = File::open("hello.txt").unwrap();
let file = File::open("hello.txt").expect("File not found!");

Conclusion

This Rust cheatsheet covers the essentials you'll need while working with Rust, from basic syntax and control flow to advanced concepts like lifetimes, concurrency, and error handling. Keep this cheatsheet handy as you work with Rust to quickly recall the syntax and concepts you need.