Kenhuang Academy
  • English

      • Rust Iterators

      Overview

      Iterators are powerful tools for processing data collections in Rust.

      🔄 Basic Iterators

      fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {}", val);
    }
}

      🔧 Iterator Adapters

      fn main() {
    let v1: Vec<i32> = vec![1, 2, 3];
    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
    println!("{:?}", v2);
}

      Continue learning: Next chapter - Rust Closures

      Rust Closures

      Overview

      Closures are anonymous functions that can capture their surrounding environment.

      🔧 Basic Closures

      fn main() {
    let expensive_closure = |num| {
        println!("calculating slowly...");
        std::thread::sleep(std::time::Duration::from_secs(2));
        num
    };

    println!("{}", expensive_closure(5));
}

      📦 Capturing Environment

      fn main() {
    let x = 4;
    let equal_to_x = |z| z == x;
    let y = 4;
    assert!(equal_to_x(y));
}

      Continue learning: Next chapter - Rust References and Borrowing

      Rust References and Borrowing

      Overview

      References allow you to use values without taking ownership.

      🔗 Immutable References

      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 References

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

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

      Continue learning: Next chapter - Rust Lifetimes

      Rust Lifetimes

      Overview

      Lifetimes ensure the validity of references.

      🕐 Lifetime Syntax

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

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";
    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

      Continue learning: Next chapter - Rust Slice Types

      Rust Slice Types

      Overview

      Slices allow you to reference a contiguous sequence of elements in a collection.

      🍰 String Slices

      fn main() {
    let s = String::from("hello world");
    let hello = &s[0..5];
    let world = &s[6..11];
    println!("{} {}", hello, world);
}

      🍰 Array Slices

      fn main() {
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3];
    println!("{:?}", slice);
}

      Continue learning: Next chapter - Rust Structs

      Rust Structs

      Overview

      Structs are custom data types that let you package related values together.

      🏗️ Defining Structs

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

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

    println!("User: {}", user1.username);
}

      🔧 Methods

      impl User {
    fn new(email: String, username: String) -> User {
        User {
            email,
            username,
            active: true,
            sign_in_count: 1,
        }
    }

    fn is_active(&self) -> bool {
        self.active
    }
}

      Continue learning: Next chapter - Rust Enums