Rust Advance Cheatsheet

Introduction

Rust is a multi-paradigm programming language designed for
Performance and safety, especially safe concurrency.
Rust is syntactically similar to C++, but can guarantee memory safety by using a borrow checker to validate references. The Advance Cheatsheet of Rust is

1. Ownership and Borrowing:

fn main() {
    let s1 = String::from("hello ali");
    let s2 = s1; 
    println!("{}", s2);
    println!("{}", s1); 
}

2. Error Handling:

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("username.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

3. Concurrency:

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

fn main() {
    let (tx, rx) = mpsc::channel();
    let handle = thread::spawn(move || {
        let val = String::from("hello");
        tx.send(val).unwrap();
    });
    let received = rx.recv().unwrap();
    println!("Got: {}", received);
    handle.join().unwrap();
}

4. Traits and Generics:

trait Animal {
    fn name(&self) -> &'static str;
}

struct Dog;

impl Animal for Dog {
    fn name(&self) -> &'static str {
        "Dog"
    }
}

fn print_name<T: Animal>(animal: T) {
    println!("This is a {}", animal.name());
}

5. Pattern Matching:

fn main() {
    let number = Some(7);
    match number {
        Some(7) => println!("Lucky number 7!"),
        Some(n) => println!("Some other number: {}", n),
        None => (),
    }
}

6. Advanced Data Structures:

use std::collections::HashMap;
[](url)
fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

7. Unsafe Rust:

unsafe fn dangerous() {
    println!("This is unsafe!");
}

fn main() {
    unsafe {
        dangerous();
    }
}

Follow for more content
Here is my Linkedin Profile Syed Muhammad Ali Raza