From 27af05de9a4d74660de8805047d26c53ac0fbf3f Mon Sep 17 00:00:00 2001
From: Nikolay Kim <fafhrd91@gmail.com>
Date: Fri, 31 Aug 2018 12:51:26 -0700
Subject: [PATCH] simplify Apply combinator

---
 src/service/apply.rs | 93 +++++++++++++++++---------------------------
 src/service/mod.rs   | 12 +++---
 2 files changed, 42 insertions(+), 63 deletions(-)

diff --git a/src/service/apply.rs b/src/service/apply.rs
index a39663d32..58755f6fa 100644
--- a/src/service/apply.rs
+++ b/src/service/apply.rs
@@ -1,24 +1,21 @@
 use std::marker::PhantomData;
 
-use futures::{Async, Future, Poll};
+use futures::{Async, Future, IntoFuture, Poll};
 use {IntoNewService, NewService, Service};
 
-/// `ApplyService` service combinator
-pub struct Apply<T, F, R, Req, Resp, Err> {
+/// `Apply` service combinator
+pub struct Apply<T, F, R, Req> {
     service: T,
     f: F,
-    r: PhantomData<R>,
-    r1: PhantomData<Req>,
-    r2: PhantomData<Resp>,
-    e: PhantomData<Err>,
+    r: PhantomData<Fn(Req) -> R>,
 }
 
-impl<T, F, R, Req, Resp, Err> Apply<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> Apply<T, F, R, Req>
 where
     T: Service,
-    T::Error: Into<Err>,
+    T::Error: Into<<R::Future as Future>::Error>,
     F: Fn(Req, &mut T) -> R,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     /// Create new `Apply` combinator
     pub fn new(f: F, service: T) -> Self {
@@ -26,49 +23,43 @@ where
             service,
             f,
             r: PhantomData,
-            r1: PhantomData,
-            r2: PhantomData,
-            e: PhantomData,
         }
     }
 }
 
-impl<T, F, R, Req, Resp, Err> Service for Apply<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> Service for Apply<T, F, R, Req>
 where
     T: Service,
-    T::Error: Into<Err>,
+    T::Error: Into<<R::Future as Future>::Error>,
     F: Fn(Req, &mut T) -> R,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     type Request = Req;
-    type Response = Resp;
-    type Error = Err;
-    type Future = R;
+    type Response = <R::Future as Future>::Item;
+    type Error = <R::Future as Future>::Error;
+    type Future = R::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(|e| e.into())
     }
 
     fn call(&mut self, req: Self::Request) -> Self::Future {
-        (self.f)(req, &mut self.service)
+        (self.f)(req, &mut self.service).into_future()
     }
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, R, Req, Resp, Err> {
+pub struct ApplyNewService<T, F, R, Req> {
     service: T,
     f: F,
-    r: PhantomData<R>,
-    r1: PhantomData<Req>,
-    r2: PhantomData<Resp>,
-    e: PhantomData<Err>,
+    r: PhantomData<Fn(Req) -> R>,
 }
 
-impl<T, F, R, Req, Resp, Err> ApplyNewService<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> ApplyNewService<T, F, R, Req>
 where
     T: NewService,
     F: Fn(Req, &mut T::Service) -> R,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     /// Create new `ApplyNewService` new service instance
     pub fn new<F1: IntoNewService<T>>(f: F, service: F1) -> Self {
@@ -76,91 +67,79 @@ where
             f,
             service: service.into_new_service(),
             r: PhantomData,
-            r1: PhantomData,
-            r2: PhantomData,
-            e: PhantomData,
         }
     }
 }
 
-impl<T, F, R, Req, Resp, Err> Clone for ApplyNewService<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> Clone for ApplyNewService<T, F, R, Req>
 where
     T: NewService + Clone,
     F: Fn(Req, &mut T::Service) -> R + Clone,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     fn clone(&self) -> Self {
         Self {
             service: self.service.clone(),
             f: self.f.clone(),
             r: PhantomData,
-            r1: PhantomData,
-            r2: PhantomData,
-            e: PhantomData,
         }
     }
 }
 
-impl<T, F, R, Req, Resp, Err> NewService for ApplyNewService<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> NewService for ApplyNewService<T, F, R, Req>
 where
     T: NewService,
-    T::Error: Into<Err>,
+    T::Error: Into<<R::Future as Future>::Error>,
     F: Fn(Req, &mut T::Service) -> R + Clone,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     type Request = Req;
-    type Response = Resp;
-    type Error = Err;
-    type Service = Apply<T::Service, F, R, Req, Resp, Err>;
+    type Response = <R::Future as Future>::Item;
+    type Error = <R::Future as Future>::Error;
+    type Service = Apply<T::Service, F, R, Req>;
 
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, R, Req, Resp, Err>;
+    type Future = ApplyNewServiceFuture<T, F, R, Req>;
 
     fn new_service(&self) -> Self::Future {
         ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, R, Req, Resp, Err>
+pub struct ApplyNewServiceFuture<T, F, R, Req>
 where
     T: NewService,
     F: Fn(Req, &mut T::Service) -> R,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     fut: T::Future,
     f: Option<F>,
-    r: PhantomData<R>,
-    r1: PhantomData<Req>,
-    r2: PhantomData<Resp>,
-    e: PhantomData<Err>,
+    r: PhantomData<Fn(Req) -> R>,
 }
 
-impl<T, F, R, Req, Resp, Err> ApplyNewServiceFuture<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> ApplyNewServiceFuture<T, F, R, Req>
 where
     T: NewService,
     F: Fn(Req, &mut T::Service) -> R,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
     fn new(fut: T::Future, f: F) -> Self {
         ApplyNewServiceFuture {
             f: Some(f),
             fut,
             r: PhantomData,
-            r1: PhantomData,
-            r2: PhantomData,
-            e: PhantomData,
         }
     }
 }
 
-impl<T, F, R, Req, Resp, Err> Future for ApplyNewServiceFuture<T, F, R, Req, Resp, Err>
+impl<T, F, R, Req> Future for ApplyNewServiceFuture<T, F, R, Req>
 where
     T: NewService,
-    T::Error: Into<Err>,
+    T::Error: Into<<R::Future as Future>::Error>,
     F: Fn(Req, &mut T::Service) -> R,
-    R: Future<Item = Resp, Error = Err>,
+    R: IntoFuture,
 {
-    type Item = Apply<T::Service, F, R, Req, Resp, Err>;
+    type Item = Apply<T::Service, F, R, Req>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
diff --git a/src/service/mod.rs b/src/service/mod.rs
index d8e13136e..940ab861d 100644
--- a/src/service/mod.rs
+++ b/src/service/mod.rs
@@ -20,12 +20,12 @@ pub use self::map_request::{MapReq, MapReqNewService};
 use {NewService, Service};
 
 pub trait ServiceExt: Service {
-    fn apply<F, R, Req, Resp, Err>(self, f: F) -> Apply<Self, F, R, Req, Resp, Err>
+    fn apply<F, R, Req>(self, f: F) -> Apply<Self, F, R, Req>
     where
         Self: Sized,
-        Self::Error: Into<Err>,
+        Self::Error: Into<<R::Future as Future>::Error>,
         F: Fn(Req, &mut Self) -> R,
-        R: Future<Item = Resp, Error = Err>,
+        R: IntoFuture,
     {
         Apply::new(f, self)
     }
@@ -57,12 +57,12 @@ pub trait ServiceExt: Service {
 }
 
 pub trait NewServiceExt: NewService {
-    fn apply<F, R, Req, Resp, Err>(self, f: F) -> ApplyNewService<Self, F, R, Req, Resp, Err>
+    fn apply<F, R, Req>(self, f: F) -> ApplyNewService<Self, F, R, Req>
     where
         Self: Sized,
-        Self::Error: Into<Err>,
+        Self::Error: Into<<R::Future as Future>::Error>,
         F: Fn(Req, &mut Self::Service) -> R + Clone,
-        R: Future<Item = Resp, Error = Err>,
+        R: IntoFuture,
     {
         ApplyNewService::new(f, self)
     }