Is State expected to be cloned 3 times per request? (and 8 times on startup)

[glandium]

See example below:

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

use axum::{extract::State, routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route(
            "/",
            get(|State(foo): State<Foo>| async move { format!("{:?}", foo) }),
        )
        .with_state(Foo {
            count: Arc::new(AtomicUsize::new(0)),
        });

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

struct Foo {
    count: Arc<AtomicUsize>,
}

impl Clone for Foo {
    fn clone(&self) -> Self {
        let count = Arc::clone(&self.count);
        count.fetch_add(1, Ordering::SeqCst);
        Self { count }
    }
}

impl std::fmt::Debug for Foo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Foo")
            .field("clone_count", &self.count)
            .field("arc_strong_count", &Arc::strong_count(&self.count))
            .finish()
    }
}

[mladedav]

Yes, see this issue.

The state isn't expected to be expensive to clone so lowering the number isn't a priority right now, but it would be great to improve this.

[glandium]

Should the documentation for State mention it?

[mladedav]

Sure, it would be good to mention the clones should be cheap. I don't think we need to explicitly document it's 3 clones as the number will hopefully change.

Also, I suspect there would be a similar number odlf clones for any middleware.