Send, 'static and Other Compile Errors in Async Rust

pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
where
    F: Future + Send + 'static,
    F::Output: Send + 'static;

error: future cannot be sent between threads safely
   --> src/main.rs:20:18
    |
20  |     tokio::spawn(update(state));
    |                  ^^^^^^^^^^^^^ future returned by `update` is not `Send`
    |
    = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `std::sync::MutexGuard<'_, Vec<u64>>`
note: future is not `Send` as this value is used across an await
   --> src/main.rs:12:28
    |
11  |     let mut guard = state.lock().unwrap();
    |         --------- has type `std::sync::MutexGuard<'_, Vec<u64>>` which is not `Send`
12  |     tick().await;
    |            ^^^^^ await occurs here, with `mut guard` maybe used later
note: required by a bound in `tokio::spawn`

use std::sync::{Arc, Mutex};

// Does not compile when spawned: guard lives across .await
async fn bad(state: Arc<Mutex<Vec<u64>>>) {
    let mut v = state.lock().unwrap();
    v.push(1);
    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
    v.push(2);
}

// Fix 1: scope the guard
async fn good_scoped(state: Arc<Mutex<Vec<u64>>>) {
    {
        let mut v = state.lock().unwrap();
        v.push(1);
    }
    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
    state.lock().unwrap().push(2);
}

// Fix 2: move the locking into a sync helper
fn push(state: &Mutex<Vec<u64>>, x: u64) {
    state.lock().unwrap().push(x);
}

// Fix 3: the guard really must span the await -> tokio::sync::Mutex
async fn good_async_mutex(state: Arc<tokio::sync::Mutex<Vec<u64>>>) {
    let mut v = state.lock().await;
    v.push(1);
    tokio::time::sleep(std::time::Duration::from_millis(10)).await; // other lockers wait, by design
    v.push(2);
}

error: future cannot be sent between threads safely
    = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `Rc<RefCell<Vec<String>>>`
note: future is not `Send` as this value is used across an await

use std::sync::{Arc, Mutex};

async fn collect(urls: Vec<String>) -> Vec<String> {
    let seen = Arc::new(Mutex::new(Vec::new())); // was Rc<RefCell<Vec<_>>>
    let mut set = tokio::task::JoinSet::new();
    for url in urls {
        let seen = Arc::clone(&seen);
        set.spawn(async move {
            tokio::task::yield_now().await;
            seen.lock().unwrap().push(url);
        });
    }
    while set.join_next().await.is_some() {}
    let out = seen.lock().unwrap().clone();
    out
}

use tracing::Instrument;

async fn traced(id: u64) {
    let span = tracing::info_span!("job", id);
    async move {
        tokio::task::yield_now().await;
        tracing::info!("inside span across awaits");
    }
    .instrument(span) // correct; `let _e = span.enter();` across .await is wrong
    .await;
}

error[E0373]: async block may outlive the current function, but it borrows `name`, which is owned by the current function
  --> src/main.rs:6:18
   |
6  |     tokio::spawn(async {
   |                  ^^^^^ may outlive borrowed value `name`
7  |         println!("{name}");
   |                    ---- `name` is borrowed here
help: to force the async block to take ownership of `name` (and any other referenced variables), use the `move` keyword

async fn start(name: String, state: std::sync::Arc<AppState>) {
    let task_state = state.clone();            // clone what the task needs
    tokio::spawn(async move {                   // move ownership into the task
        task_state.log(&name).await;
    });
    state.log("parent still has its Arc").await;
}

error[E0597]: `config` does not live long enough
  ...
  argument requires that `config` is borrowed for `'static`

use futures::{StreamExt, stream::FuturesUnordered};

async fn check_all(urls: &[String], http: &reqwest::Client) -> usize {
    let mut pending: FuturesUnordered<_> = urls.iter().map(|u| http.head(u).send()).collect();
    let mut ok = 0;
    while let Some(res) = pending.next().await {
        if res.is_ok_and(|r| r.status().is_success()) {
            ok += 1;
        }
    }
    ok
}

error[E0277]: the trait bound `fn(Json<NewOrder>, State<Arc<AppState>>) -> impl Future<Output = ...> {create}: Handler<_, _>` is not satisfied

pub trait OrderRepo {
    async fn find(&self, id: i64) -> anyhow::Result<Option<Order>>;
}

use std::future::Future;

pub trait OrderRepo: Send + Sync + 'static {
    fn find(&self, id: i64) -> impl Future<Output = anyhow::Result<Option<Order>>> + Send;
}

pub struct PgRepo { pool: sqlx::PgPool }

impl OrderRepo for PgRepo {
    async fn find(&self, id: i64) -> anyhow::Result<Option<Order>> { // async fn satisfies the impl Future signature
        Ok(sqlx::query_as::<_, Order>("SELECT id, sku, qty FROM orders WHERE id = $1")
            .bind(id)
            .fetch_optional(&self.pool)
            .await?)
    }
}

error[E0733]: recursion in an async fn requires boxing

use std::{future::Future, pin::Pin};

fn walk(depth: u32) -> Pin<Box<dyn Future<Output = u32> + Send>> {
    Box::pin(async move {
        if depth == 0 { 0 } else { 1 + walk(depth - 1).await }
    })
}

#[allow(dead_code)]
fn assert_send<T: Send>(_: &T) {}

#[test]
fn handler_futures_are_send() {
    let state = test_state();
    let fut = load_order_for_test(state, 1); // do not await; just build the future
    assert_send(&fut);
}