pretzelhammer/rust-blog

In Rust, a type is sized if its size in bytes can be determined at compile-time. This allows instances of the type to be allocated on the stack and passed by value.

If a type's size cannot be determined at compile-time, it is an unsized type (also known as a DST or Dynamically-Sized Type). Unsized types cannot be placed on the stack and must be passed around by reference.

Terminology Summary

WebAssembly (wasm32) is a stack-based Instruction Set Architecture (ISA). Instructions operate by pushing and popping values from an implicit stack.

Key concepts:

• Stack Operations: Instructions like i32.const push values onto the stack, while arithmetic instructions like i32.add pop values, perform the operation, and push the result back.
• S-expressions: WebAssembly Textual Format (WAT) supports S-expression syntax for improved readability, e.g., (i32.add (i32.const 4) (i32.const 5)).
• Discarding Values: Use the drop instruction to remove a value from the stack if it is not needed.
• Strong Typing: All values and instructions are strongly typed. The four available data types are i32, i64, f32, and f64. Mixing types results in a compile error.

i32.const 4     ;; push value 4 onto stack
i32.const 5     ;; push value 5 onto stack
i32.add         ;; pop 2 values from stack, add them, push result onto stack

;; Alternatively using S-expressions:
(i32.add (i32.const 4) (i32.const 5))

;; Discarding a value:
i32.const 14
drop

This document summarizes key technical nuances regarding Rust lifetimes to avoid common misunderstandings:

Types and Lifetimes

• T is a superset of &T and &mut T.
• &T and &mut T are independent of each other.
• T: 'static should be read as "T is bounded by the 'static lifetime".
• If T: 'static, T can be an owned type OR a borrowed type that owns a 'static lifetime.
• T: 'static implies T contains owned data, which means it:
  • Can be dynamically allocated at runtime.
  • Does not necessarily need to be valid for the entire duration of the program.
  • Is safe and can be modified freely.
  • Can be dynamically dropped at runtime.
  • Can have lifetimes of different durations.
• T: 'a is more general and flexible than &'a T.
• T: 'a can be an owned type containing references, or a type that accepts references.
• &'a T only accepts references.
• Since 'static >= 'a for any 'a, if T: 'static, then T: 'a is also true.

Generics and Inference

• Most Rust code is generic; lifetimes are often elided (omitted) everywhere.
• Rust's lifetime elision rules are not always correct for every situation.
• Trait objects have inferred default lifetime bounds.
• Lifetime elision rules for trait objects are not always correct.
• A function with the signature for<'a, T> fn() -> &'a T is more flexible than for<T> fn() -> &'static T.

Best Practices and Compiler Behavior

• Use descriptive names for lifetime annotations.
• Be intentional about where and why you apply explicit lifetime annotations.
• The Rust compiler's suggested fixes aim to make code compile, but they may not satisfy the actual semantic requirements of your program.
• Avoid reborrowing a mutable reference as a shared reference if it leads to unexpected behavior.
• Even if a mutable reference is dropped, its lifetime does not end if it was reborrowed.
• Rust does not know the semantic meaning of your program better than you do.

If you want to learn Rust using a practical, hands-on approach rather than reading theoretical documentation first, follow these paths based on your current level:

For Total Newbies

1. Read A half-hour to learn Rust by fasterthanlime.
2. Complete the exercises in the Rustlings repository.

For Beginners

1. Start the Exercism Rust Track.
2. Use the Rust Standard Library Docs to navigate and find practical examples.
3. Use Rust by Example as a high-level reference for syntax and features.
4. Only consult The Book when you need a deep dive into a specific concept.
5. Review other members' solutions on Exercism (sorted by most-starred) to learn idiomatic patterns.

For Advanced Beginners

1. Work through the Advent of Code 2018 exercises.
2. Compare your solutions to BurntSushi's Advent of Code 2018 Rust solutions to learn clean, readable, and idiomatic Rust code.

Implement authentication by creating a Token struct and implementing the rocket::request::FromRequest trait for it. This allows you to protect routes by simply adding _t: Token as a parameter to your handler functions. The implementation should:

1. Check for the presence of the Authorization header.
2. Verify the header uses the Bearer <token> format.
3. Use the application's managed state (e.g., State<Db>) to validate the token against a database.
4. Return Outcome::Success(token) if valid, or appropriate Outcome::Failure (e.g., Unauthorized or BadRequest) if invalid.

use rocket::request::{FromRequest, Request, Outcome};
use crate::models::Token;

impl<'a, 'r> FromRequest<'a, 'r> for Token {
    type Error = &'static str;
    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
        // ... implementation logic to validate Bearer token ...
    }
}

// Usage in a route:
#[rocket::get("/boards")]
fn boards(db: State<Db>, _t: Token) -> Result<Json<Vec<Board>>, StdErr> {
    db.boards().map(Json)
}