rework Handler trait

src/handler.rs

@@ -17,7 +17,7 @@ use crate::{
 ///   [`HttpResponse`] (i.e., it implements the [`Responder`] trait).
 ///
 /// # Compiler Errors
-/// If you get the error `the trait Handler<_, _, _> is not implemented`, then your handler does not
+/// If you get the error `the trait Handler<_> is not implemented`, then your handler does not
 /// fulfill one or more of the above requirements.
 ///
 /// Unfortunately we cannot provide a better compile error message (while keeping the trait's
@@ -77,20 +77,18 @@ use crate::{
 /// [arity]: https://en.wikipedia.org/wiki/Arity
 /// [`from_request`]: FromRequest::from_request
 /// [on_unimpl]: https://github.com/rust-lang/rust/issues/29628
-pub trait Handler<Args, R>: Clone + 'static
+pub trait Handler<Args>: Clone + 'static {
-where
+    type Output;
-    R: Future,
+    type Future: Future<Output = Self::Output>;
-    R::Output: Responder,
+
-{
+    fn call(&self, args: Args) -> Self::Future;
-    fn call(&self, args: Args) -> R;
 }
 
-pub(crate) fn handler_service<F, Args, R>(handler: F) -> BoxedHttpServiceFactory
+pub(crate) fn handler_service<F, Args>(handler: F) -> BoxedHttpServiceFactory
 where
-    F: Handler<Args, R>,
+    F: Handler<Args>,
     Args: FromRequest,
-    R: Future,
+    F::Output: Responder,
-    R::Output: Responder,
 {
     boxed::factory(fn_service(move |req: ServiceRequest| {
         let handler = handler.clone();
@@ -122,14 +120,16 @@ where
 /// factory_tuple! { A B C }  // implements Handler for types: fn(A, B, C) -> R
 /// ```
 macro_rules! factory_tuple ({ $($param:ident)* } => {
-    impl<Func, $($param,)* R> Handler<($($param,)*), R> for Func
+    impl<Func, Fut, $($param,)*> Handler<($($param,)*)> for Func
-    where Func: Fn($($param),*) -> R + Clone + 'static,
+    where Func: Fn($($param),*) -> Fut + Clone + 'static,
-          R: Future,
+          Fut: Future,
-          R::Output: Responder,
     {
+        type Output = Fut::Output;
+        type Future = Fut;
+
         #[inline]
         #[allow(non_snake_case)]
-        fn call(&self, ($($param,)*): ($($param,)*)) -> R {
+        fn call(&self, ($($param,)*): ($($param,)*)) -> Self::Future {
             (self)($($param,)*)
         }
     }

src/resource.rs

@@ -230,12 +230,11 @@ where
     /// # fn index(req: HttpRequest) -> HttpResponse { unimplemented!() }
     /// App::new().service(web::resource("/").route(web::route().to(index)));
     /// ```
-    pub fn to<F, Args, R>(mut self, handler: F) -> Self
+    pub fn to<F, Args>(mut self, handler: F) -> Self
     where
-        F: Handler<Args, R>,
+        F: Handler<Args>,
         Args: FromRequest + 'static,
-        R: Future + 'static,
+        F::Output: Responder + 'static,
-        R::Output: Responder + 'static,
     {
         self.routes.push(Route::new().to(handler));
         self

src/route.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, mem, rc::Rc};
+use std::{mem, rc::Rc};
 
 use actix_http::Method;
 use actix_service::{
@@ -175,12 +175,11 @@ impl Route {
     ///     );
     /// }
     /// ```
-    pub fn to<F, Args, R>(mut self, handler: F) -> Self
+    pub fn to<F, Args>(mut self, handler: F) -> Self
     where
-        F: Handler<Args, R>,
+        F: Handler<Args>,
         Args: FromRequest + 'static,
-        R: Future + 'static,
+        F::Output: Responder + 'static,
-        R::Output: Responder + 'static,
     {
         self.service = handler_service(handler);
         self

src/web.rs

@@ -146,12 +146,11 @@ pub fn method(method: Method) -> Route {
 ///         web::to(index))
 /// );
 /// ```
-pub fn to<F, Args, R>(handler: F) -> Route
+pub fn to<F, Args>(handler: F) -> Route
 where
-    F: Handler<Args, R>,
+    F: Handler<Args>,
     Args: FromRequest + 'static,
-    R: Future + 'static,
+    F::Output: Responder + 'static,
-    R::Output: Responder + 'static,
 {
     Route::new().to(handler)
 }