Thought dump

The repository for the book Future Explained in 200 Lines of Rust

Data + Vtable

We need to get a basic grasp of this to be able to understand how we implement a Waker.

Next concept is Pin. What guarantee do we give/get?

Not too deep into Pin, the real need for this trait relates to the internals of Futureand Async/Await implementation which is another 200 lines of .... book. Interesting but really an implementation detail.
Next book, talk about dtolnay's await!macro. Check if it's feasable to make our own to see what the compiler really does. Why Pinis needed.

TODO:

Find Rfc's to point to for more information about concepts. also to double check my conclusions.

Run this code in the playground:

use std::rc::Rc;

fn main() {
    use std::mem::size_of;

    println!("Size of Box<i32>: {}", size_of::<Box<i32>>());
    println!("Size of &i32: {}", size_of::<&i32>());
    println!("Size of &Box<i32>: {}", size_of::<&Box<i32>>());
    println!("Size of Box<Trait>: {}", size_of::<Box<MyTrait>>());
    println!("Size of &dyn Trait: {}", size_of::<&dyn MyTrait>());
    println!("Size of Rc<i32>: {}", size_of::<Rc<i32>>());
    println!("Size of Box<Rc<i32>>: {}", size_of::<Box<Rc<i32>>>());
    println!("Size of Rc<Trait>: {}", size_of::<Rc<MyTrait>>());
    println!("Size of &[i32]: {}", size_of::<&[i32]>());
    println!("Size of &[&dyn Trait]: {}", size_of::<&[&dyn MyTrait]>());
    println!("Size of [i32; 10]: {}", size_of::<[i32; 10]>());
    println!("Size of [&dyn Trait; 10]: {}", size_of::<[&dyn MyTrait; 10]>());
}

trait MyTrait {
    fn do_something(&self) {
        println!("See, something");
    }
}

Smart pointers = Data + Vtable

Dynamic Dispatch - short intro

For more information about this:

{% embed url="https://alschwalm.com/blog/static/2017/03/07/exploring-dynamic-dispatch-in-rust/" %}

Create our own "fat pointer". We need to do this when we create Wakers anyway so let's get to know them a little. It's probably the thing that's most difficult implementation wise.

Bonus - pointer types

Normal pointer: just a memory location. Basic pointer type we all know (reference/pointer)

Fat pointer: pointer plus some other information (slice length, a second pointer to trait information for a trait object). 16 byte pointer, not only compiler "hint".

Smart pointer: a pointer-like type that add behaviour or restrictions eg Box deallocates when dropped, Rc tracks how many shared owner there currently are. Compiler only!

2.5 KiB Raw Blame History