Yet Another Rust Resource

https://yet-another-rust-resource.pages.dev/
Admin
A crash course in Rust programming designed to teach software engineers the fundamentals of Rust...
Tokens:13,120
Snippets:173
Trust Score:7.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Create and Navigate Project Directory in Rust

Source: https://yet-another-rust-resource.pages.dev/hello-world

Commands to create a new directory for a Rust project and navigate into it. Assumes the user is starting from their home directory.

```bash
cd ~
mkdir yarr
cd yarr
```

--------------------------------

### Rust Documentation Tests (Doctests)

Source: https://yet-another-rust-resource.pages.dev/testing

Shows how to embed runnable code examples directly within Rust documentation comments (`///`). These examples are compiled and executed as tests when `cargo test` is run, ensuring documentation accuracy. Code blocks within docstrings are recognized as tests.

```rust
#![allow(unused)]
fn main() {
/// Adds together two numbers, and doesn't handle rollover.
///
/// ```
/// use playground::plus;
/// assert_eq!(30, plus(10, 20));
/// ```
pub fn plus(x: i32, y: i32) -> i32 { x + y }
}
```

--------------------------------

### Rust Fibonacci Function Stub

Source: https://yet-another-rust-resource.pages.dev/print

This snippet shows the initial setup for a Fibonacci function in Rust, including a main function to call it and a stub function that returns a dummy value. It serves as a starting point before implementing the actual recursive logic.

```rust
fn main() {
    let x = fibonacci(10);
    println!("{x}");
}

fn fibonacci(n: u32) -> u32 {
    0
}
```

--------------------------------

### Create a New Rust Project with Cargo

Source: https://yet-another-rust-resource.pages.dev/hello-world

Uses the Cargo build system to create a new binary application named 'hello_world'. Cargo handles project structure and initial setup.

```bash
cargo new hello_world
Created binary (application) `hello_world` package
```

--------------------------------

### Python Async Function Example

Source: https://yet-another-rust-resource.pages.dev/async

Demonstrates defining and running an asynchronous function in Python using `asyncio`. It shows how to fetch data asynchronously and execute the main async function.

```python
import asyncio

async def fetch_data():
    # ...

async def main():
    data = await fetch_data()
    print(data)

asyncio.run(main())
```

--------------------------------

### Check Rustup Version

Source: https://yet-another-rust-resource.pages.dev/setup

This command checks the installed version of the rustup toolchain manager. It's a preliminary step to ensure Rust is set up correctly on your local machine.

```bash
rustup --version
```

--------------------------------

### Rust Unit Tests

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates how to write unit tests in Rust using a `#[cfg(test)]` module and `#[test]` functions. It includes examples of successful and failing tests, highlighting assertion macros like `assert_eq!`.

```rust
#![allow(unused)]
fn main() {
pub fn plus(x: i32, y: i32) -> i32 {
    x + y
}

// this cfg says "only compile this if the test compile option is on"
#[cfg(test)]
// by convention we call this "tests" but it doesn't need to be
mod tests {
    // usually you avoid importing all, but it's idiomatic for tests
    use super::*;

    // this is how we mark this function as a test
    #[test]
    fn adds_small_numbers() {
        let x = 10;
        let y = 20;
        let expected = 30;
        assert_eq!(plus(x, y), expected, "should add up correctly");
    }

    // this test WILL FAIL because the integers roll over
    #[test]
    fn adds_big_numbers() {
        let x = 2_000_000_000;
        let y = 2_000_000_000;
        assert!(plus(x, y) > 0, "result should be positive");
    }
}
}

```

--------------------------------

### Rust: Explicit Lifetime Annotation Example

Source: https://yet-another-rust-resource.pages.dev/ownership

Shows how to use explicit lifetime annotations in Rust. This example defines a generic function that takes a reference with a specific lifetime 'a and returns a reference with the same lifetime.

```rust
#![allow(unused)]
fn main() {
fn example<'a>(x: &'a u32) {
    let y: &'a u32 = &x;
}
}
```

--------------------------------

### TypeScript Async Function Example

Source: https://yet-another-rust-resource.pages.dev/async

Illustrates defining and executing an asynchronous function in TypeScript. It uses the `async` and `await` keywords for non-blocking operations and logs the fetched data.

```typescript
async function fetchData(): Promise<string> {
    // ...
}

async function main() {
    const data = await fetchData();
    console.log(data);
}

main();
```

--------------------------------

### Rust: Invoking Returned Closure (Printing Message)

Source: https://yet-another-rust-resource.pages.dev/closures

Demonstrates how to call a closure that was returned from a function. The example first creates the closure and then invokes it to perform its action (printing a message).

```rust
#![allow(unused)]
fn main() {
// this line creates a new function, f
let f = print_msg("hello, world");
// nothing has been printed yet

// and this line invokes the function, which will print our message
f();
}

```

--------------------------------

### TypeScript Enum Example

Source: https://yet-another-rust-resource.pages.dev/print

Provides an example of an enum declaration in TypeScript for representing days of the week. Enums are used for named constants.

```typescript
enum WeekDay {
    Monday = 0,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

```

--------------------------------

### Run Rust Linter (`cargo clippy`)

Source: https://yet-another-rust-resource.pages.dev/linting-formatting

Invokes the `cargo clippy` command to lint Rust code and provide suggestions for idiomatic improvements. Requires `clippy` to be installed separately. Treats warnings as errors by default for better code quality.

```bash
cargo clippy
```

--------------------------------

### Rust: Implicit Lifetime Elision Example

Source: https://yet-another-rust-resource.pages.dev/ownership

Presents an example of Rust's lifetime elision, where explicit lifetime annotations can be omitted. This function takes and returns a reference without explicit lifetime markers, relying on the compiler's inference.

```rust
#![allow(unused)]
fn main() {
fn example(x: &u32) {
    let y: &u32 = &x;
}
}
```

--------------------------------

### Rust Documentation Tests

Source: https://yet-another-rust-resource.pages.dev/print

Illustrates writing tests directly within Rust documentation comments (`///`). Code blocks within these docstrings are compiled and executed by `cargo test`, ensuring documentation examples stay up-to-date.

```rust
#![allow(unused)]
fn main() {
/// Adds together two numbers, and doesn't handle rollover.
///
/// ```
/// use playground::plus;
/// assert_eq!(30, plus(10, 20));
/// ```
pub fn plus(x: i32, y: i32) -> i32 { x + y }
}

```

--------------------------------

### While Loop in Rust

Source: https://yet-another-rust-resource.pages.dev/control-flow

Illustrates a `while` loop in Rust that executes as long as a given condition is true. This example increments a counter and prints its value in each iteration.

```rust
#![allow(unused)]
fn main() {
let mut count = 0;

while count < 10 {
    count += 1;
    println!("iteration {count}");
}
}
```

--------------------------------

### Update Rustup Toolchain

Source: https://yet-another-rust-resource.pages.dev/setup

This command updates all installed Rust toolchains, including the default 'nightly' toolchain, to their latest available versions. Keeping the toolchain updated ensures you have the newest features and bug fixes.

```bash
rustup update
```

--------------------------------

### Rust Fizzbuzz exercise setup

Source: https://yet-another-rust-resource.pages.dev/functions

This Rust code snippet provides the 'main' function for a Fizzbuzz exercise. It calls a function 'fizzbuzz_up_to' with the argument 100, setting up the scenario for the user to implement the Fizzbuzz logic.

```rust
fn main() {
    fizzbuzz_up_to(100);
}
```

--------------------------------

### Rust Integration Tests

Source: https://yet-another-rust-resource.pages.dev/testing

Illustrates how to write integration tests for a Rust crate. Integration tests are placed in a `tests/` directory and can only access the public API of the crate. Each file in `tests/` is compiled as a separate crate. The `#[test]` attribute marks test functions.

```rust
#![allow(unused)]
fn main() {
use my_library::plus;

#[test]
fn test_addition() {
    assert_eq!(plus(10, 20), 30);
}
}
```

--------------------------------

### Rust Panic Macro Example

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates the use of the `panic!` macro in Rust to intentionally cause a program termination due to an exceptional condition. This is typically used for unrecoverable errors or broken invariants.

```rust
#![allow(unused)]
fn main() {
    let index = 10;
    if index > 5 {
        panic!("Index is out of bounds!");
    }

    // ...
}
```

--------------------------------

### Instantiating and Accessing Rust Enum Variants

Source: https://yet-another-rust-resource.pages.dev/enums

Provides examples of creating instances for each variant of the `LanguageResource` enum (Website, Book, SelfTeaching) and accessing their associated data using dot notation for named fields and index notation for positional fields. This illustrates how to work with enum instances in Rust.

```rust
#![allow(unused)]
fn main() {
enum LanguageResource {
   Website(String),
   Book { title: String, pages: u64 },
   SelfTeaching,
}
let site = LanguageResource::Website("https://yet-another-rust-resource.pages.dev/".to_owned());
let book = LanguageResource::Book { title: "The Rust Programming Language".to_owned(), pages: 300 };
let independent = LanguageResource::SelfTeaching;

println!("the site is at {}", site.0);
println!("the book {} is {} pages long", book.title, book.pages);
}
```

--------------------------------

### Rust Block Shadowing Example

Source: https://yet-another-rust-resource.pages.dev/print

Shows how a variable within an inner block can shadow an outer variable of the same name. The outer variable's value remains unchanged after the inner block completes.

```rust
#![allow(unused)]
fn main() {
let msg = "Hello, world";
{
    // we're in the pirate block now
    let msg = "Ahoy, matey!";
    println!("{msg}");
}
println!("{msg}");
}
```

--------------------------------

### Rust Unit Tests

Source: https://yet-another-rust-resource.pages.dev/testing

Demonstrates writing unit tests within a Rust project. Tests are typically placed in a submodule marked with `#[cfg(test)]` and use the `#[test]` attribute. The `assert_eq!` macro is commonly used for checking equality. These tests are only compiled when the test flag is enabled, ensuring they are not part of release builds.

```rust
#![allow(unused)]
fn main() {
pub fn plus(x: i32, y: i32) -> i32 {
    x + y
}

// this cfg says "only compile this if the test compile option is on"
#[cfg(test)]
// by convention we call this "tests" but it doesn't need to be
mod tests {
    // usually you avoid importing all, but it's idiomatic for tests
    use super::*;

    // this is how we mark this function as a test
    #[test]
    fn adds_small_numbers() {
        let x = 10;
        let y = 20;
        let expected = 30;
        assert_eq!(plus(x, y), expected, "should add up correctly");
    }

    // this test WILL FAIL because the integers roll over
    #[test]
    fn adds_big_numbers() {
        let x = 2_000_000_000;
        let y = 2_000_000_000;
        assert!(plus(x, y) > 0, "result should be positive");
    }
}
}
```

--------------------------------

### Rust: Returning a Closure with `move` (Counter)

Source: https://yet-another-rust-resource.pages.dev/closures

Provides an example of returning a closure that acts as a counter in Rust. The `move` keyword is used to transfer ownership of the `count` variable to the closure. The closure mutates and returns the count.

```rust
#![allow(unused)]
fn main() {
fn make_counter() -> impl FnMut() -> u32 {
    let mut count = 0;
    let increment = move || {
        count += 1;
        count
    };
    increment
}
}

```

--------------------------------

### Generic Struct 'Point' in Rust

Source: https://yet-another-rust-resource.pages.dev/generics

Illustrates a generic struct `Point` that can hold coordinates of a single generic type `T`. Examples show creating `Point` instances with integer and floating-point types.

```rust
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 3.14, y: 6.28 };

    println!("Integer point: ({}, {})", integer_point.x, integer_point.y);
    println!("Floating point: ({}, {})", float_point.x, float_point.y);
}
```

--------------------------------

### Move Value in Vector Iteration in Rust

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates how iterating over a vector by value moves ownership, making the original vector unusable. This example shows a common mistake for new Rust programmers and how the compiler prevents it.

```rust
#![allow(unused)]
fn main() {
let xs = vec![1,2,3];

for x in xs {
    println!("{x}");
}

println!("total len: {}", xs.len());
}
```

--------------------------------

### Use `Read` Trait from Standard Library in Rust

Source: https://yet-another-rust-resource.pages.dev/traits

Demonstrates the necessity of importing traits from the standard library to use their methods. The example shows a scenario where reading from a byte slice fails without `use std::io::Read;` and succeeds after the import, highlighting trait visibility and scope.

```rust
let mut s: Vec<u8> = "sad example".into();
let mut buf: [u8; 32] = [0; 32];
(&s[..]).read(&mut buf);
```

```rust
use std::io::Read;

let mut s: Vec<u8> = "sad example".into();
let mut buf: [u8; 32] = [0; 32];
(&s[..]).read(&mut buf);
```

--------------------------------

### Iterate over a Vector by Value (Move) in Rust

Source: https://yet-another-rust-resource.pages.dev/ownership

Demonstrates iterating over a vector by value, which moves the vector's ownership into the loop. This makes the original vector inaccessible after the loop. This example does not compile.

```Rust
let xs = vec![1,2,3];

for x in xs {
    println!("{x}");
}

println!("total len: {}", xs.len());
```

--------------------------------

### Define KeyValueStore Trait with Default Method in Rust

Source: https://yet-another-rust-resource.pages.dev/traits

Demonstrates defining a `KeyValueStore` trait in Rust. It includes abstract methods (`set`, `get`, `lock`, `unlock`) that must be implemented by structs, and a default method (`get_and_set`) that utilizes these abstract methods. This showcases how traits can provide shared behavior with flexibility for specific implementations.

```rust
#![allow(unused)]
fn main() {
trait KeyValueStore {
    // These ones have to be implemented by structs which impl KeyValueStore
    fn set(&mut self, key: &str, value: Vec<u8>);
    fn get(&self, key: &str) -> Option<Vec<u8>>;
    fn lock(&mut self, key: &str);
    fn unlock(&mut self, key: &str);

    // This one is defined for all KeyValueStores
    fn get_and_set(&mut self, key: &str, value: Vec<u8>) -> Option<Vec<u8>> {
        self.lock(key);

        let old_value = self.get(key);
        self.set(key, value);

        self.unlock(key);
        old_value
    }
}
}
```

--------------------------------

### For Loop with Range in Rust

Source: https://yet-another-rust-resource.pages.dev/control-flow

Demonstrates a `for` loop in Rust iterating over a range of numbers. The first example uses an exclusive range (0 to 9), and the second uses an inclusive range (1 to 10).

```rust
#![allow(unused)]
fn main() {
for count in 0..10 {
    println!("iteration {}", count+1);
}
}
```

```rust
#![allow(unused)]
fn main() {
for count in 1..=10 {
    println!("iteration {count}");
}
}
```

--------------------------------

### Rust Type Casting Example

Source: https://yet-another-rust-resource.pages.dev/variables

Demonstrates casting a variable of type u8 to i64 to perform addition with a variable of type i64. This highlights Rust's explicit casting requirement to avoid type mismatches and potential overflow.

```rust
#![allow(unused)]
fn main() {
let x: i64 = -13;
let y: u8 = 10;
let z = x + (y as i64);
}
```

--------------------------------

### Rust: Iterating with while let

Source: https://yet-another-rust-resource.pages.dev/advanced-control-flow

Shows how to use `while let` in Rust for loops that continue as long as a pattern matches. This example iterates over a vector using `iter().next()`, printing each value until the iterator returns `None`. It's a common pattern for processing sequences or enums.

```Rust
#![allow(unused)]
fn main() {
let values = vec![1, 2, 3, 4, 5];
let mut iter = values.iter();

while let Some(v) = iter.next() {
    println!("v = {v}");
}
}
```

--------------------------------

### Rust: Mutable Variable Declaration and Assignment

Source: https://yet-another-rust-resource.pages.dev/variables

Shows how to declare a mutable variable 'x' using the 'mut' keyword in Rust, allowing its value to be changed. This example successfully assigns 11 to 'x' after its initial declaration.

```rust
#![allow(unused)]
fn main() {
let mut x = 10;
x = 11;
}
```

--------------------------------

### Generic Struct 'Point2' with Multiple Types in Rust

Source: https://yet-another-rust-resource.pages.dev/generics

Shows a generic struct `Point2` that can hold coordinates of two different generic types, `X` and `Y`. An example demonstrates creating a `Point2` instance with an integer and a float.

```rust
struct Point2<X, Y> {
    x: X,
    y: Y,
}

fn main() {
    let mixed_point = Point2 { x: 5, y: 6.28 };

    println!("Mixed point: ({}, {})", mixed_point.x, mixed_point.y);
}
```

--------------------------------

### Implementing `is_some` Method for a Rust Enum

Source: https://yet-another-rust-resource.pages.dev/enums

Shows how to define custom methods for a Rust enum. This example implements an `is_some` method for the `MyOption<T>` enum, which returns `true` if the enum instance is `Some(T)` and `false` if it is `None`.

```rust
#![allow(unused)]
fn main() {
enum MyOption<T> {
   Some(T),
   None,
}
impl<T> MyOption<T> {
    pub fn is_some(&self) -> bool {
        match self {
            MyOption::Some(_) => true,
            MyOption::None => false,
        }
    }
}
}
```

--------------------------------

### Iterate over a Vector by Reference (Borrow) in Rust

Source: https://yet-another-rust-resource.pages.dev/ownership

Illustrates iterating over a vector by reference, which borrows the vector without taking ownership. This allows the original vector to be used after the loop. This example compiles successfully.

```Rust
let xs = vec![1,2,3];

for x in &xs {
    println!("{x}");
}

println!("total len: {}", xs.len());
```

--------------------------------

### Rust: Explicit Type Annotations for String and Integer

Source: https://yet-another-rust-resource.pages.dev/variables

Demonstrates how to explicitly define the types for variables in Rust. This example shows declaring a string slice named 'name' and a 32-bit unsigned integer named 'age' with their types.

```rust
#![allow(unused)]
fn main() {
let name: &str = "Captain Blackbeard";
let age: u32 = 35;
}
```

--------------------------------

### Create and Navigate Project Directory (Shell)

Source: https://yet-another-rust-resource.pages.dev/print

Commands to create a new directory, navigate into it, and set up a Rust project using Cargo.

```shell
$ cd ~
$ mkdir yarr
$ cd yarr
```

--------------------------------

### Run a Rust Project with Cargo

Source: https://yet-another-rust-resource.pages.dev/hello-world

Navigates into the newly created project directory and then uses Cargo to compile and run the Rust program. The default program prints 'Hello, world!'.

```bash
cd hello_world
carousel run
   Compiling hello_world v0.1.0 (/home/ntietz/Code/ntietz/rust-crash-course/hello_world)
    Finished dev [unoptimized + debuginfo] target(s) in 0.55s
     Running `target/debug/hello_world`
Hello, world!
```

--------------------------------

### Update and Run Custom Rust Program

Source: https://yet-another-rust-resource.pages.dev/hello-world

Removes the default main.rs file, replaces it with custom code, and then recompiles and runs the Rust program using Cargo to display the new greeting.

```bash
rm src/main.rs

fn main() {
    println!("Ahoy, matey!");
}

carousel run
   Compiling hello_world v0.1.0 (/home/ntietz/Code/ntietz/rust-crash-course/hello_world)
    Finished dev [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/hello_world`
Ahoy, matey!
```

--------------------------------

### Create New Rust Project with Cargo (Shell)

Source: https://yet-another-rust-resource.pages.dev/print

Uses the Cargo build system to create a new binary application project named 'hello_world'.

```shell
$ cargo new hello_world
Created binary (application) `hello_world` package
```

--------------------------------

### Rust: Create a Vec using the vec! macro

Source: https://yet-another-rust-resource.pages.dev/heap-allocation

Demonstrates creating a `Vec` with initial values using the convenient `vec!` macro. This is a concise way to initialize a vector.

```rust
#![allow(unused)]
fn main() {
let parrots = vec!["Shivers", "Tweety", "Dinner"];
println!("parrots: {:?}", parrots);
}
```

--------------------------------

### Rust: Create and Populate a Vec with String Slices

Source: https://yet-another-rust-resource.pages.dev/print

Shows two common methods for creating and populating a `Vec<&str>` (a vector of string slices). The first uses `Vec::new()` and `push()`, while the second utilizes the `vec!` macro for inline initialization.

```Rust
#![allow(unused)]
fn main() {
let mut parrots: Vec<&str> = Vec::new();
parrots.push("Shivers");
parrots.push("Tweety");
parrots.push("Dinner");
println!("parrots: {:?}", parrots);
}
```

```Rust
#![allow(unused)]
fn main() {
let parrots = vec!["Shivers", "Tweety", "Dinner"];
println!("parrots: {:?}", parrots);
}
```

--------------------------------

### Run a Rust Program with Cargo (Shell)

Source: https://yet-another-rust-resource.pages.dev/print

Compiles and executes the Rust program located in the 'hello_world' project using the Cargo command.

```shell
$ cd hello_world
$ cargo run
   Compiling hello_world v0.1.0 (/home/ntietz/Code/ntietz/rust-crash-course/hello_world)
    Finished dev [unoptimized + debuginfo] target(s) in 0.55s
     Running `target/debug/hello_world`
Hello, world!
```

--------------------------------

### Run Rust Formatter (`cargo fmt`)

Source: https://yet-another-rust-resource.pages.dev/linting-formatting

Executes the `cargo fmt` command to format Rust code according to standard conventions. No external dependencies beyond the Rust toolchain are required. This command takes no arguments.

```bash
cargo fmt
```

--------------------------------

### Write Custom 'Hello, world!' in Rust

Source: https://yet-another-rust-resource.pages.dev/hello-world

This Rust code defines the main function and uses the `println!` macro to display a custom greeting 'Ahoy, matey!' to the console.

```rust
fn main() {
    println!("Ahoy, matey!");
}
```

--------------------------------

### Adding Crates with Cargo

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates the command-line usage of `cargo add` to include external dependencies into a Rust project's `Cargo.toml` file.

```shell
cargo add serde

```

--------------------------------

### Rust Integration Tests

Source: https://yet-another-rust-resource.pages.dev/print

Shows how to write integration tests for a Rust crate by placing test files in the `tests/` directory. These tests consume the public API of the library.

```rust
#![allow(unused)]
fn main() {
use my_library::plus;

#[test]
fn test_addition() {
    assert_eq!(plus(10, 20), 30);
}
}

```

--------------------------------

### Set Rustup to Nightly Toolchain

Source: https://yet-another-rust-resource.pages.dev/setup

This command sets the 'nightly' Rust toolchain as the default for your environment. Using the nightly toolchain allows access to the latest features and improvements in Rust.

```bash
rustup default nightly
```

--------------------------------

### Rust Pattern Matching with Result

Source: https://yet-another-rust-resource.pages.dev/error-handling

Demonstrates how to use Rust's `match` control flow construct to handle the different variants (Ok or Err) of a Result type. This ensures errors are explicitly addressed.

```rust
fn main() {
    let result = some_function();

    match result {
        Ok(value) => println!("Success: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}

fn some_function() -> Result<String, String> {
    // ...
    Ok(String::from("Success")) // Placeholder
}
```

--------------------------------

### Instantiate Rust Struct with Field Shorthand

Source: https://yet-another-rust-resource.pages.dev/structs

Demonstrates creating an instance of a Rust struct, showing both explicit field assignment and the shorthand syntax when a variable name matches a field name.

```rust
#![allow(unused)]
fn main() {
struct PirateShip {
   captain: String,
   crew: Vec<String>,
   treasure: f64,
}
let blackbeard = "Blackbeard".to_owned();
let crew = vec!["Scurvy".to_owned(), "Rat".to_owned(), "Polly".to_owned()];
let ship = PirateShip {
    captain: blackbeard,
    crew,
    treasure: 64.0,
};
}
```

--------------------------------

### Rust Closures: Using Returned Closure (Print Message)

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates how to call a function that returns a closure. The returned closure is first assigned to a variable, and then invoked to execute its logic.

```rust
#![allow(unused)]
fn main() {
// this line creates a new function, f
let f = print_msg("hello, world");
// nothing has been printed yet

// and this line invokes the function, which will print our message
f();
}
```

--------------------------------

### Importing Items into Scope with 'use' in Rust

Source: https://yet-another-rust-resource.pages.dev/modules

Demonstrates how to use the 'use' keyword to bring items from the standard library, specifically 'HashMap' from 'std::collections', into the current scope.

```rust
#![allow(unused)]
fn main() {
use std::collections::HashMap;
}
```

--------------------------------

### Rust Block withPrintln

Source: https://yet-another-rust-resource.pages.dev/print

Illustrates a basic Rust code block delimiting scope and executing a print statement. Demonstrates how variables declared within a block are local to that scope.

```rust
#![allow(unused)]
fn main() {
{
    println!("I'm in a block!");
}
}
```

--------------------------------

### Rust: Iterate over Vec elements

Source: https://yet-another-rust-resource.pages.dev/heap-allocation

Shows how to iterate over the elements of a `Vec` using a `for` loop and the `.iter()` method. Each element is borrowed immutably during iteration.

```rust
#![allow(unused)]
fn main() {
let parrots = vec!["Shivers", "Tweety", "Dinner"];
for parrot in parrots.iter() {
    println!("{} says hi.", parrot);
}
}
```

--------------------------------

### Rust: Create and populate a Vec with push

Source: https://yet-another-rust-resource.pages.dev/heap-allocation

Illustrates creating a mutable `Vec` of string slices and adding elements using the `push` method. `Vec` is Rust's type for dynamically sized arrays.

```rust
#![allow(unused)]
fn main() {
let mut parrots: Vec<&str> = Vec::new();
parrots.push("Shivers");
parrots.push("Tweety");
parrots.push("Dinner");
println!("parrots: {:?}", parrots);
}
```

--------------------------------

### Rust: Allocate value on the heap with Box::new

Source: https://yet-another-rust-resource.pages.dev/heap-allocation

Demonstrates allocating primitive types (u32, f64) on the heap using `Box::new`. This is useful when the size is unknown at compile time or when data needs to live beyond its scope.

```rust
#![allow(unused)]
fn main() {
let x: Box<u32> = Box::new(42);
let y = Box::<f64>::new(4.2);
}
```

--------------------------------

### Rust Closure Syntax: Annotated and Inferred

Source: https://yet-another-rust-resource.pages.dev/closures

Demonstrates the basic syntax for creating Rust closures with both explicitly annotated and inferred types. Closures use pipes `||` for parameters and an expression for the return value.

```rust
#![allow(unused)]
fn main() {
let y: u32 = 10;
let annotated = |x: u32| -> u32 { x + y };
let inferred = |x| x + y;

println!("annotated: {}", annotated(32));
println!("inferred: {}", inferred(32));
}
```

--------------------------------

### Rust Awaiting an Async Function

Source: https://yet-another-rust-resource.pages.dev/async

Demonstrates how to use the `.await` keyword within an asynchronous Rust function to call another async function and handle its result. This requires the calling function to also be `async`.

```rust
async fn main() {
    match fetch_data().await {
        Ok(data) => println!("Data: {}", data),
        Err(error) => println!("Error: {}", error),
    }
}
```

--------------------------------

### Handling Result Variants with Pattern Matching in Rust

Source: https://yet-another-rust-resource.pages.dev/print

Illustrates how to use Rust's pattern matching (match statement) to handle the different variants of a Result type. This is a common and safe way to process operations that may succeed or fail.

```rust
fn main() {
    let result = some_function();

    match result {
        Ok(value) => println!("Success: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}

fn some_function() -> Result<String, String> {
    // ...
    Ok("Success value".to_string())
}
```

--------------------------------

### Rust Async Function Definition

Source: https://yet-another-rust-resource.pages.dev/async

Shows how to define an asynchronous function in Rust using the `async fn` syntax. The function returns a `Result` and represents a Future that can be awaited.

```rust
#![allow(unused)]
fn main() {
async fn fetch_data() -> Result<String, String> {
    // ...
}
}
```

--------------------------------

### Borrow Vector in Iteration using Reference in Rust

Source: https://yet-another-rust-resource.pages.dev/print

Illustrates how to iterate over a vector by reference to borrow it, allowing the original vector to remain usable after the loop. This avoids moving ownership and enables subsequent operations on the vector.

```rust
#![allow(unused)]
fn main() {
let xs = vec![1,2,3];

for x in &xs {
    println!("{x}");
}

println!("total len: {}", xs.len());
}
```

--------------------------------

### Using and Matching Rust Option Enum

Source: https://yet-another-rust-resource.pages.dev/enums

Demonstrates two common ways to interact with a Rust `Option` type: using built-in methods like `is_some()` and `unwrap()`, and employing pattern matching with a `match` statement. Both methods achieve the goal of handling the `Some` and `None` cases.

```rust
#![allow(unused)]
fn main() {
let x = Some(3);

if x.is_some() {
    println!("x = {}", x.unwrap());
} else {
    println!("x is empty :(");
}

match x {
    Some(v) => println!("x = {v}"),
    None => println!("x is empty :("),
}
}
```

--------------------------------

### Define Empty Rust Struct

Source: https://yet-another-rust-resource.pages.dev/structs

Demonstrates the basic syntax for defining an empty struct in Rust, which serves as a blueprint for data structures.

```rust
#![allow(unused)]
fn main() {
struct PirateShip {
}
}
```

--------------------------------

### Derive Debug and PartialEq Traits in Rust

Source: https://yet-another-rust-resource.pages.dev/traits

Illustrates using the `derive` attribute in Rust to automatically implement traits for a struct. Specifically, it shows how to derive `Debug` for printing struct instances and `PartialEq` for comparing instances for equality. This simplifies trait implementation for common functionalities.

```rust
#![allow(unused)]
fn main() {
#[derive(Debug, PartialEq)]
struct PirateShip {
    name: String,
    masts: f32, // float since you can have part of a mast
}
}
```

--------------------------------

### Rust If-Else Statement and Expression

Source: https://yet-another-rust-resource.pages.dev/control-flow

Illustrates the usage of if-else statements in Rust, including optional parentheses for conditions and the requirement for curly braces even for single statements. It also shows how if-else can be used as an expression to return a value.

```Rust
#![allow(unused)]
fn main() {
if plunder > 5 {
    println!("A good haul");
} else {
    println!("Just jetsam");
}
}
```

```Rust
#![allow(unused)]
fn main() {
let is_crew_member = true;
let greeting = if is_crew_member {
    "Ahoy!!! Welcome aboard!"
} else {
    "Yarrrrr get off me ship"
};
println!("{}", greeting);
}
```

--------------------------------

### Rust Function Accepting Trait Implementation

Source: https://yet-another-rust-resource.pages.dev/traits

Demonstrates passing a type that implements a specific trait as a function parameter using `impl`. This ensures the function can work with any type that satisfies the trait's contract, with compile-time resolution to the concrete type.

```rust
#![allow(unused)]
fn main() {
fn save_record(kv: &impl KeyValueStore) {
    // use the key value store somehow
}
}
```

--------------------------------

### Rust: Returning a Closure with `move` (Printing Message)

Source: https://yet-another-rust-resource.pages.dev/closures

Shows how to return a closure from a function in Rust using the `move` keyword. The closure captures a string slice and prints it. It requires explicit lifetime annotation on the return type.

```rust
#![allow(unused)]
fn main() {
fn print_msg<'a>(msg: &'a str) -> impl Fn() + 'a {
    let printer = move || {
        println!("{msg}");
    };
    printer
}
}

```

--------------------------------

### Rust Block Returning a Value

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates a Rust code block used as an expression that calculates and returns a value. The result of the block is assigned to a variable, and temporary variables within the block are deallocated upon completion.

```rust
#![allow(unused)]
fn main() {
let parrots = 5;
let shipmates = 10;

let legs_on_ship = {
    let parrot_legs = 2 * parrots;
    let human_legs = 2 * shipmates;
    parrot_legs + human_legs
};
}
```

--------------------------------

### Implement Methods for Rust Struct

Source: https://yet-another-rust-resource.pages.dev/structs

Illustrates how to add methods to a Rust struct using an `impl` block. Includes methods for reading fields (`&self`) and modifying fields (`&mut self`).

```rust
#![allow(unused)]
fn main() {
struct PirateShip {
   captain: String,
   crew: Vec<String>,
   treasure: f64,
}
impl PirateShip {
    pub fn count_treasure(&self) -> f64 {
        // some computations probably
        self.treasure
    }

    pub fn mutiny(&mut self) {
        if self.crew.len() > 0 {
            // replace the captain with one of the crew
            self.captain = self.crew.pop().unwrap();
        } else {
            println!("there's no crew to perform mutiny");
        }
    }
}
}
```

--------------------------------

### Rust Panic Macro Usage

Source: https://yet-another-rust-resource.pages.dev/error-handling

Shows how to explicitly trigger a panic in Rust using the `panic!` macro. This is typically used for unrecoverable errors where the program cannot safely continue.

```rust
fn main() {
    let index = 10;
    if index > 5 {
        panic!("Index is out of bounds!");
    }

    // ...
    println!("This line will not be reached if index > 5");
}
```

--------------------------------

### Rust If-Else Statement

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates a basic if-else statement in Rust to print different messages based on a condition. The condition does not require parentheses.

```rust
#![allow(unused)]
fn main() {
if plunder > 5 {
    println!("A good haul");
} else {
    println!("Just jetsam");
}
}
```

--------------------------------

### Rust: Move value from heap to stack using dereference operator

Source: https://yet-another-rust-resource.pages.dev/heap-allocation

Shows how to move a heap-allocated value back onto the stack by dereferencing a `Box`. The value `y` becomes a `u32` on the stack after dereferencing `x`.

```rust
#![allow(unused)]
fn main() {
let x: Box<u32> = Box::new(42);
let y = *x; // y is now a u32 on the stack
}
```

--------------------------------

### Add Rust Crate with Cargo

Source: https://yet-another-rust-resource.pages.dev/dependency-management

This command adds the latest version of a specified crate to your Rust project's dependencies. It utilizes the cargo build system to manage packages.

```rust
cargo add serde
```

--------------------------------

### Dereferencing a Rust Reference

Source: https://yet-another-rust-resource.pages.dev/memory-management

Demonstrates how to create a reference to a variable and explicitly dereference it to access the underlying value. This is a fundamental operation for working with references in Rust.

```rust
#![allow(unused)]
fn main() {
// First create a variable, x
let x: u32 = 10;

// Then create a reference to it:
let ref_x: &u32 = &x;

// Then print out the reference!
println!("x = {}", *ref_x);
}
```

--------------------------------

### Rust Closures: Returning from Functions (Print Message)

Source: https://yet-another-rust-resource.pages.dev/print

Shows how to return a closure from a function. The `move` keyword is used to transfer ownership of captured variables into the closure. The closure is annotated with its lifetime and the `Fn()` trait.

```rust
#![allow(unused)]
fn main() {
fn print_msg<'a>(msg: &'a str) -> impl Fn() + 'a {
    let printer = move || {
        println!("{msg}");
    };
    printer
}
}
```

--------------------------------

### Rust: Loop with conditional break returning a value (Compiles)

Source: https://yet-another-rust-resource.pages.dev/control-flow

This Rust code demonstrates the correct way to return a value from a loop using the `loop` keyword and a conditional `break` statement. This pattern successfully compiles, showcasing how to emit a value from a loop when a specific condition is met.

```rust
#![allow(unused)]
fn main() {
let mut count = 0;

let x = loop {
    if count > 1 {
        break count * 2;
    }

    count += 1;
};
}
```

--------------------------------

### Rust: Conditional Execution with if let

Source: https://yet-another-rust-resource.pages.dev/advanced-control-flow

Demonstrates using `if let` in Rust to execute code conditionally based on a pattern match. It checks if a `Some` variant contains a value and prints it, otherwise, it executes an `else` block. This is useful for handling specific enum variants.

```Rust
#![allow(unused)]
fn main() {
// let's just pretend we got this from a map, okay?
let value = Some(42);

if let Some(inner) = value {
    println!("inner was {inner}");
} else {
    println!("this is the failure case!");
}
}
```

--------------------------------

### Rust If-Else Expression for Value Assignment

Source: https://yet-another-rust-resource.pages.dev/print

Shows how to use an if-else expression in Rust to assign a value to a variable conditionally. This is the idiomatic way to handle conditional assignments.

```rust
#![allow(unused)]
fn main() {
let is_crew_member = true;
let greeting = if is_crew_member {
    "Ahoy!!! Welcome aboard!"
} else {
    "Yarrrrr get off me ship"
};
println!("{}", greeting);
}
```

--------------------------------

### Rust: 'static Lifetime for String Literal

Source: https://yet-another-rust-resource.pages.dev/ownership

Demonstrates the use of the 'static lifetime annotation in Rust for string literals. This indicates that the string data will live for the entire duration of the program.

```rust
#![allow(unused)]
fn main() {
let msg: &'static str = "hello, world!";
}
```

--------------------------------

### Rust Function Returning Trait Implementation

Source: https://yet-another-rust-resource.pages.dev/traits

Illustrates using `impl` in a function's return type to signify that the function returns a value conforming to a specific trait. The function must consistently return a single concrete type that implements the specified trait.

```rust
#![allow(unused)]
fn main() {
fn create_in_memory_kvstore(config: Config) -> impl KeyValueStore {
    // create and return the KeyValueStore
    todo!()
}
}
```

--------------------------------

### Define Rust Struct with Fields

Source: https://yet-another-rust-resource.pages.dev/structs

Shows how to define a Rust struct with fields of different data types, such as String, Vec<String>, and f64.

```rust
#![allow(unused)]
fn main() {
struct PirateShip {
    captain: String,
    crew: Vec<String>,
    treasure: f64,
}
}
```

--------------------------------

### Rust Closures: Using Returned Closure (Counter)

Source: https://yet-another-rust-resource.pages.dev/print

Shows how to use a closure returned from a function that manages mutable state. The closure must be declared as mutable (`mut`) to be called, as it modifies its captured state.

```rust
#![allow(unused)]
fn main() {
let mut counter = make_counter();

println!("count is {}", counter()); // prints 1
println!("count is {}", counter()); // prints 2
println!("count is {}", counter()); // prints 3
}
```

--------------------------------

### Rust Error Propagation with ?

Source: https://yet-another-rust-resource.pages.dev/error-handling

Illustrates the usage of the '?' operator in Rust for simplifying error handling. It automatically returns an Err value from the function if the operation fails, otherwise unwraps the Ok value.

```rust
fn main() {
    match read_config() {
        Ok(config) => println!("Config: {:?}", config),
        Err(error) => println!("Error: {}", error),
    }
}

fn read_config() -> Result<String, String> {
    let file = read_file("config.txt")?;
    let parsed = parse_config(&file)?;
    Ok(parsed)
}

fn read_file(path: &str) -> Result<String, String> {
    // ... Placeholder implementation
    if path == "config.txt" {
        Ok(String::from("key=value"))
    } else {
        Err(String::from("File not found"))
    }
}

fn parse_config(file_contents: &str) -> Result<String, String> {
    // ... Placeholder implementation
    if file_contents.contains("=") {
        Ok(file_contents.to_string())
    } else {
        Err(String::from("Invalid config format"))
    }
}
```

--------------------------------

### Define a Rust function to add 10 to a u32

Source: https://yet-another-rust-resource.pages.dev/functions

This Rust code defines a function named 'add_10' that accepts a 32-bit unsigned integer 'x' and returns 'x' plus 10. It demonstrates basic function definition, parameter typing, and return type specification in Rust.

```rust
#![allow(unused)]
fn main() {
fn add_10(x: u32) -> u32 {
    let value = x + 10;
    value
}
}
```

--------------------------------

### Implement Printable Trait for Ship Struct in Rust

Source: https://yet-another-rust-resource.pages.dev/traits

Shows how to implement a custom `Printable` trait for a `Ship` struct in Rust. The `Printable` trait has a `print` method. The implementation for `Ship` defines how a `Ship` instance should be printed, demonstrating the association of behavior with specific data types.

```rust
#![allow(unused)]
fn main() {
trait Printable {
    fn print(&self);
}

struct Ship {
    name: String
}

impl Printable for Ship {
    fn print(&self) {
        println!("<Ship name=\"{}\">", self.name);
    }
}
}
```

--------------------------------

### Pass Trait as Function Parameter using impl Trait in Rust

Source: https://yet-another-rust-resource.pages.dev/print

Shows how to define a function `save_record` that accepts any type implementing the `KeyValueStore` trait as a parameter. This allows for generic behavior without explicit generic type parameters.

```rust
fn save_record(kv: &impl KeyValueStore) {
    // use the key value store somehow
}
```

--------------------------------

### Simplifying Error Handling with the ? Operator in Rust

Source: https://yet-another-rust-resource.pages.dev/print

Demonstrates the use of the '?' operator in Rust for simplifying error propagation. When used on an expression returning a Result, it automatically returns the Err value if an error occurs, or unwraps the Ok value otherwise.

```rust
fn main() {
    match read_config() {
        Ok(config) => println!("Config: {:?}", config),
        Err(error) => println!("Error: {}", error),
    }
}

fn read_config() -> Result<String, String> {
    let file = read_file("config.txt")?;
    let parsed = parse_config(&file)?;
    Ok(parsed)
}

fn read_file(path: &str) -> Result<String, String> {
    // Placeholder for file reading logic
    if path == "config.txt" {
        Ok("file contents".to_string())
    } else {
        Err("File not found".to_string())
    }
}

fn parse_config(file_contents: &str) -> Result<String, String> {
    // Placeholder for parsing logic
    if file_contents.contains("valid") {
        Ok("parsed config".to_string())
    } else {
        Err("Invalid config format".to_string())
    }
}
```

--------------------------------

### Infinite Loop in Rust

Source: https://yet-another-rust-resource.pages.dev/control-flow

Demonstrates an infinite `loop` in Rust that prints a message repeatedly. This loop requires manual interruption using the `break` keyword to terminate.

```rust
#![allow(unused)]
fn main() {
// Don't do this, it will run forever
loop {
    println!("Wheeeee");
}
}
```
Tokens:
Raw