Extracting generic substate

[mhutter]

Summary

Given a state like

struct AppState<G: Greeter> {
    greeter: G,
}

Is it at all possible to have handlers that extract the greeter substate instead of the whole state? Something like this:

async fn handler<G: Greeter>(State(greeter): State<G>) -> /* ... */

axum version

0.7.5

[jplatte]

Yes, this should be possible by writing an impl<G: Greeter> FromRef<AppState> for G and specifying the generic type to use when registering the handler, as in:

app.route("/path", get(handler::<TypeThatImplementsHandler>))

[mhutter]

Yes that's what I tried, but

impl<G: Greeter> FromRef<AppState<G>> for G {
    fn from_ref(state: &AppState<G>) -> Self {
        state.greeter.clone()
    }
}

Yields an error

 32 | impl<G: Greeter> FromRef<AppState<G>> for G {
    |      ^ type parameter `G` must be covered by another type when it appears before the first local type (`AppState<G>`)

So I tried implementing FromRef for each concrete type:

impl FromRef<AppState<UniverseGreeter>> for UniverseGreeter { /* ... */ }
impl FromRef<AppState<WorldGreeter>> for WorldGreeter { /* ... */ }

But this now complains about my AppState's type:

 15  | async fn run_app<G>(greeter: G)
     |                  - expected this type parameter
 ...
 23  |         .with_state(state);
     |          ---------- ^^^^^ expected type parameter `G`, found `AppState<G>`
     |          |
     |          arguments to this method are incorrect
     |
     = note: expected type parameter `G`
                        found struct `AppState<G>`

[mhutter]

Okay, I figured it out.

While I was on the right track, what was missing was a trait bound X: AsRef<AppState<X>>.

So this works:

// Trait & Implementations
trait Greeter: Clone + Send + Sync + 'static { /* ... */ }
impl Greeter for WorldGreeter { /* ... */ }
impl Greeter for UniverseGreeter { /* ... */ }

// Handler that uses Greeter
async fn homepage<G: Greeter>(State(greeter): State<G>) -> { /* ... */ }

// AppState that contains Greeter
struct AppState<G: Greeter> {
    greeter: G,
}

// FromRef implementations
impl FromRef<AppState<UniverseGreeter>> for UniverseGreeter { /* ... */ }
impl FromRef<AppState<WorldGreeter>> for WorldGreeter { /* ... */ }

// Putting it all together
async fn run_app<G>(greeter: G)
where
    G: Greeter + FromRef<AppState<G>>,  // <--- I was missing FromRef<...> here!
{
    let state = AppState { greeter };
    let app = Router::new()
        .route("/", get(homepage::<G>))
        .with_state(state);

    /* ... */
}