The state machine transformation is not specific to any async libraries. The compiler is the one that desugars async fns / blocks to state machines. AFAIK there is nothing other than dumping the HIR / MIR from rustc to inspect it. But even without that the transformation is pretty straightforward to do mentally.

The first transformation is that every async block / fn compiles to a generator where `future.await` is essentially replaced by `loop { match future.poll() { Ready(value) => break value, Pending => yield } }`. ie either polling the inner future will resolve immediately, or it will return Pending and yield the generator, and the next time the generator is resumed it will go back to the start of the loop to poll the future again.

The second transformation is that every generator compiles to essentially an enum. Every variant of the enum represents one region of code between two `yield`s, and the data of that variant is all the local variables that in the scope of that region.

Putting both together:

    async fn foo(i: i32, j: i32) {
        sleep(5).await;
        i + j
    }

... essentially compiles to:

    fn foo(i: i32, j: i32) -> FooFuture {
        FooFuture::Step0 { i, j }
    }

    enum FooFuture {
        Step0 { i: i32, j: i32 }
        Step1 { i: i32, j: i32, sleep: SleepFuture }
        Step2,
    }

    impl Future for FooFuture {
        fn poll(self) -> Poll<i32> {
            loop {
                match self {
                    Self::Step0 { i, j } => {
                        let sleep = sleep(5);
                        self = Self::Step1 { i, j, sleep };
                    }

                    Self::Step1 { i, j, sleep } => {
                        let () = match sleep.poll() {
                            Poll::Ready(()) => (),
                            Poll::Pending => return Poll::Pending,
                        };
                        self = Self::Step2;
                        return Poll::Ready(i + j);
                    }

                    Self::Step2 => panic!("already run to completion"),
                }
            }
        }
    }