Handler introspection

[Luni-4]

Summary

I want to introspect an Handler in order to get its return value. Below a code example showing my problem.

#[derive(Serialize, Deserialize)]
struct Payload(Option<serde_json::Value>);

impl Payload {
    fn new(value: impl Serialize) -> core::result::Result<Self, InternalError> {
        serde_json::to_value(value)
            .map(|value| Self(Some(value)))
            .map_err(|_| InternalError::new("Error"))
    }
}

impl IntoResponse for Payload {
    fn into_response(self) -> Response {
        (StatusCode::OK, Json(self.0)).into_response()
    }
}

#[derive(Serialize, Deserialize)]
struct InternalError(&'static str);

impl InternalError {
    pub fn new(info: &'static str) -> Self {
        Self(info)
    }
}

impl IntoResponse for InternalError {
    fn into_response(self) -> Response {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(self.0)).into_response()
    }
}

#[derive(Clone, Default)]
struct MyState(Arc<Mutex<DummyStruct>>);

#[derive(Serialize)]
struct Response1 {
    parameter1: f64,
    parameter2: bool,
}

#[derive(Deserialize)]
struct Inputs {
    parameter1: f64,
    #[serde(rename = "my-name")]
    parameter2: bool,
}

async fn first(
    Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>,
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1: input.parameter1,
        parameter2: input.parameter2,
    })
}

Is it possible to retrieve in some way Result<Payload, InternalError> either at compile time or at runtime? I was able to retrieve the parameters of first through the std::any::type_name::<H::Future>() method, but I'm not able to retrieve its return value. Thanks a lot for your help!

axum version

0.7.5

[jplatte]

Yes, this is possible (at compile time). Basically, you have to define your own Handler-like trait that it implemented for all of the types of your handler functions. Something like this should work:

trait GetAsyncFnReturnTypeName<Args> {
    const TYPE_NAME: &'static str;
}

impl<F, Fut> GetAsyncFnReturnTypeName<()> for F
where
    F: FnOnce() -> Fut,
    Fut: Future,
{
    const TYPE_NAME: &'static str = type_name::<Fut::Output>();
}

impl<F, A1, Fut> GetAsyncFnReturnTypeName<(A1,)> for F
where
    F: FnOnce(A1) -> Fut,
    Fut: Future,
{
    const TYPE_NAME: &'static str = type_name::<Fut::Output>();
}

impl<F, A1, A2, Fut> GetAsyncFnReturnTypeName<(A1, A2)> for F
where
    F: FnOnce(A1, A2) -> Fut,
    Fut: Future,
{
    const TYPE_NAME: &'static str = type_name::<Fut::Output>();
}

// ... for as many arguments as you need

if you have your own fns that are generic over a Handler argument, you will have to change that from H: Handler<T, S> to H: Handler<T, S> + GetAsyncFnReturnTypeName<T>, then it should work.

[Luni-4]

Thanks a lot! I was able to compile your example on nightly enabling #![feature(const_type_name)].

I searched for aide and I've found this trait, but it's not object safe. My initial idea was just to impede compilation when the return value was not correct. So a simple != comparison exectued at runtime, but if it's not possible I can try to provide a trait to a developer

[jplatte]

Oh, I was under the impression that type_name as a const fn was stable. You could do the same thing as an associated fn or even fn(&self) of course, to get around the nightly requirement. But I don't really understand why you would want to solve this through a runtime check, rather than at compile time.

[Luni-4]

Yep, I might try fn and fn(&self) as well.

Anyway, the general context is the following one. A developer would like to use Builder to pass two methods: first and second throgh the add_method function. The first method should be accepted because it has Result<Payload, InternalError> as return value, while second should be rejected. I'm not interested if it will be rejected at compile time or at runtime. Obviously, I'd rather prefer second to be rejected at compile time, if it's possible.

async fn first(
    Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>,
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1: input.parameter1,
        parameter2: input.parameter2,
    })
}

async fn second(
    Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>,
)  {
    let a = state.0.lock().await;
}

Builder::new()
.add_method(first)
.add_method(second)
.build();

Is this solution possible without a developer implementing a trait?

[Luni-4]

I want to share my solution which also answers to this discussion.

use core::any::type_name;
use core::future::Future;

#[rustfmt::skip]
macro_rules! all_the_tuples {
    ($name:ident) => {
        $name!([], T1);
        $name!([T1], T2);
        $name!([T1, T2], T3);
        $name!([T1, T2, T3], T4);
        $name!([T1, T2, T3, T4], T5);
        $name!([T1, T2, T3, T4, T5], T6);
        $name!([T1, T2, T3, T4, T5, T6], T7);
        $name!([T1, T2, T3, T4, T5, T6, T7], T8);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8], T9);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9], T10);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T11);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], T12);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], T13);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], T14);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], T15);
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], T16);
    };
}

pub(crate) mod private {
    pub trait OutputTypeName<Args> {
        fn output_type_name(&self) -> &'static str;
    }
}

impl<F, Fut> private::OutputTypeName<()> for F
where
    F: FnOnce() -> Fut,
    Fut: Future<Output = Result<Payload, InternalError>> + Send,
{
    fn output_type_name(&self) -> &'static str {
        type_name::<Fut::Output>()
    }
}

macro_rules! impl_output_type_name {
    (
        [$($ty:ident),*], $last:ident
    ) => {
        impl<F, Fut, M, $($ty,)* $last> private::OutputTypeName<(M, $($ty,)* $last,)> for F
        where
            F: FnOnce($($ty,)* $last,) -> Fut,
            Fut: Future<Output = Result<DevicePayload, DeviceError>> + Send,
            {
                fn output_type_name(&self) -> &'static str {
                    type_name::<Fut::Output>()
                }
            }
    };
}

all_the_tuples!(impl_output_type_name);

Then I redefined add_method of Builder

fn add_method<H, T>(mut self, handler: H) -> Self
    where
        H: Handler<T, ()> + OutputTypeName<T>,
        T: 'static,
    {
         ....
         self
    }

in order to obtain this outcome

async fn first(
    Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>,
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1: input.parameter1,
        parameter2: input.parameter2,
    })
}

async fn second(
    Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>,
)  {
    let a = state.0.lock().await;
}

Builder::new()
.add_method(first)
.add_method(second)
.build();

Thanks a lot @jplatte for your help! 😃