From bff68c3f76025c752b9df12ebce7e1d9c05e45b9 Mon Sep 17 00:00:00 2001
From: Rob Ede <robjtede@icloud.com>
Date: Wed, 16 Dec 2020 18:06:31 +0000
Subject: [PATCH] phase 2 / 4

---
 actix-service/src/and_then.rs          | 102 +++++++++++-----------
 actix-service/src/and_then_apply_fn.rs | 116 ++++++++++++++-----------
 actix-service/src/apply.rs             |  76 ++++++++--------
 actix-service/src/apply_cfg.rs         |  76 ++++++++--------
 actix-service/src/boxed.rs             |  56 +++++-------
 actix-service/src/fn_service.rs        | 107 ++++++++++++-----------
 actix-service/src/lib.rs               |  90 ++++++++-----------
 actix-service/src/map.rs               |  79 ++++++++---------
 actix-service/src/map_config.rs        |  76 ++++++++--------
 actix-service/src/map_err.rs           |  75 ++++++++--------
 actix-service/src/map_init_err.rs      |  31 ++++---
 actix-service/src/pipeline.rs          |  98 ++++++++++++---------
 actix-service/src/then.rs              | 100 ++++++++++-----------
 actix-service/src/transform.rs         |  76 +++++++---------
 actix-service/src/transform_err.rs     |  45 +++++-----
 15 files changed, 592 insertions(+), 611 deletions(-)

diff --git a/actix-service/src/and_then.rs b/actix-service/src/and_then.rs
index caaf8615..4ff24e03 100644
--- a/actix-service/src/and_then.rs
+++ b/actix-service/src/and_then.rs
@@ -1,8 +1,8 @@
-use std::cell::RefCell;
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
+use std::{cell::RefCell, marker::PhantomData};
 
 use super::{Service, ServiceFactory};
 
@@ -10,34 +10,33 @@ use super::{Service, ServiceFactory};
 /// of another service which completes successfully.
 ///
 /// This is created by the `Pipeline::and_then` method.
-pub(crate) struct AndThenService<A, B>(Rc<RefCell<(A, B)>>);
+pub(crate) struct AndThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
 
-impl<A, B> AndThenService<A, B> {
+impl<A, B, Req> AndThenService<A, B, Req> {
     /// Create new `AndThen` combinator
     pub(crate) fn new(a: A, b: B) -> Self
     where
-        A: Service,
-        B: Service<Request = A::Response, Error = A::Error>,
+        A: Service<Req>,
+        B: Service<A::Response, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))))
+        Self(Rc::new(RefCell::new((a, b))), PhantomData)
     }
 }
 
-impl<A, B> Clone for AndThenService<A, B> {
+impl<A, B, Req> Clone for AndThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        AndThenService(self.0.clone())
+        AndThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B> Service for AndThenService<A, B>
+impl<A, B, Req> Service<Req> for AndThenService<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenServiceResponse<A, B>;
+    type Future = AndThenServiceResponse<A, B, Req>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         let mut srv = self.0.borrow_mut();
@@ -49,7 +48,7 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         AndThenServiceResponse {
             state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())),
         }
@@ -57,30 +56,30 @@ where
 }
 
 #[pin_project::pin_project]
-pub(crate) struct AndThenServiceResponse<A, B>
+pub(crate) struct AndThenServiceResponse<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
 {
     #[pin]
-    state: State<A, B>,
+    state: State<A, B, Req>,
 }
 
 #[pin_project::pin_project(project = StateProj)]
-enum State<A, B>
+enum State<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
 {
     A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
     B(#[pin] B::Future),
     Empty,
 }
 
-impl<A, B> Future for AndThenServiceResponse<A, B>
+impl<A, B, Req> Future for AndThenServiceResponse<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
 {
     type Output = Result<B::Response, A::Error>;
 
@@ -110,13 +109,13 @@ where
 }
 
 /// `.and_then()` service factory combinator
-pub(crate) struct AndThenServiceFactory<A, B>
+pub(crate) struct AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -124,13 +123,13 @@ where
     inner: Rc<(A, B)>,
 }
 
-impl<A, B> AndThenServiceFactory<A, B>
+impl<A, B, Req> AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -143,25 +142,24 @@ where
     }
 }
 
-impl<A, B> ServiceFactory for AndThenServiceFactory<A, B>
+impl<A, B, Req> ServiceFactory<Req> for AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = AndThenService<A::Service, B::Service>;
+    type Service = AndThenService<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = AndThenServiceFactoryResponse<A, B>;
+    type Future = AndThenServiceFactoryResponse<A, B, Req>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         let inner = &*self.inner;
@@ -172,13 +170,13 @@ where
     }
 }
 
-impl<A, B> Clone for AndThenServiceFactory<A, B>
+impl<A, B, Req> Clone for AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -191,10 +189,10 @@ where
 }
 
 #[pin_project::pin_project]
-pub(crate) struct AndThenServiceFactoryResponse<A, B>
+pub(crate) struct AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Request = A::Response>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response>,
 {
     #[pin]
     fut_a: A::Future,
@@ -205,10 +203,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Request = A::Response>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenServiceFactoryResponse {
@@ -220,12 +218,12 @@ where
     }
 }
 
-impl<A, B> Future for AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Future for AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Output = Result<AndThenService<A::Service, B::Service>, A::InitError>;
+    type Output = Result<AndThenService<A::Service, B::Service, Req>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -263,8 +261,7 @@ mod tests {
 
     struct Srv1(Rc<Cell<usize>>);
 
-    impl Service for Srv1 {
-        type Request = &'static str;
+    impl Service<&'static str> for Srv1 {
         type Response = &'static str;
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
@@ -282,8 +279,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
-        type Request = &'static str;
+    impl Service<&'static str> for Srv2 {
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
diff --git a/actix-service/src/and_then_apply_fn.rs b/actix-service/src/and_then_apply_fn.rs
index b62cf505..f0602b3d 100644
--- a/actix-service/src/and_then_apply_fn.rs
+++ b/actix-service/src/and_then_apply_fn.rs
@@ -8,10 +8,10 @@ use std::task::{Context, Poll};
 use crate::{Service, ServiceFactory};
 
 /// `Apply` service combinator
-pub(crate) struct AndThenApplyFn<A, B, F, Fut, Res, Err>
+pub(crate) struct AndThenApplyFn<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
@@ -20,10 +20,10 @@ where
     r: PhantomData<(Fut, Res, Err)>,
 }
 
-impl<A, B, F, Fut, Res, Err> AndThenApplyFn<A, B, F, Fut, Res, Err>
+impl<A, B, F, Fut, Req, Res, Err> AndThenApplyFn<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
@@ -37,10 +37,10 @@ where
     }
 }
 
-impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Res, Err>
+impl<A, B, F, Fut, Req, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
@@ -53,18 +53,17 @@ where
     }
 }
 
-impl<A, B, F, Fut, Res, Err> Service for AndThenApplyFn<A, B, F, Fut, Res, Err>
+impl<A, B, F, Fut, Req, Res, Err> Service<Req> for AndThenApplyFn<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
 {
-    type Request = A::Request;
     type Response = Res;
     type Error = Err;
-    type Future = AndThenApplyFnFuture<A, B, F, Fut, Res, Err>;
+    type Future = AndThenApplyFnFuture<A, B, F, Fut, Req, Res, Err>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         let mut inner = self.srv.borrow_mut();
@@ -76,7 +75,7 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         let fut = self.srv.borrow_mut().0.call(req);
         AndThenApplyFnFuture {
             state: State::A(fut, Some(self.srv.clone())),
@@ -85,24 +84,24 @@ where
 }
 
 #[pin_project::pin_project]
-pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
+pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error>,
     Err: From<B::Error>,
 {
     #[pin]
-    state: State<A, B, F, Fut, Res, Err>,
+    state: State<A, B, F, Fut, Req, Res, Err>,
 }
 
 #[pin_project::pin_project(project = StateProj)]
-enum State<A, B, F, Fut, Res, Err>
+enum State<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error>,
@@ -113,10 +112,10 @@ where
     Empty,
 }
 
-impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
+impl<A, B, F, Fut, Req, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Fut, Req, Res, Err>
 where
-    A: Service,
-    B: Service,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
     F: FnMut(A::Response, &mut B) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
@@ -150,15 +149,19 @@ where
 }
 
 /// `AndThenApplyFn` service factory
-pub(crate) struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+pub(crate) struct AndThenApplyFnFactory<A, B, F, Req, Fut, Res, Err> {
     srv: Rc<(A, B, F)>,
-    r: PhantomData<(Fut, Res, Err)>,
+    r: PhantomData<(Req, Fut, Res, Err)>,
 }
 
-impl<A, B, F, Fut, Res, Err> AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
+impl<A, B, F, Fut, Req, Res, Err> AndThenApplyFnFactory<A, B, F, Req, Fut, Res, Err>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<
+        Result<A::Response, A::Error>,
+        Config = A::Config,
+        InitError = A::InitError,
+    >,
     F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
@@ -172,7 +175,7 @@ where
     }
 }
 
-impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+impl<A, B, F, Req, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Req, Fut, Res, Err> {
     fn clone(&self) -> Self {
         Self {
             srv: self.srv.clone(),
@@ -181,22 +184,26 @@ impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res,
     }
 }
 
-impl<A, B, F, Fut, Res, Err> ServiceFactory for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
+impl<A, B, F, Req, Fut, Res, Err> ServiceFactory<Req>
+    for AndThenApplyFnFactory<A, B, F, Req, Fut, Res, Err>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    B: ServiceFactory<
+        Result<A::Response, A::Error>,
+        Config = A::Config,
+        InitError = A::InitError,
+    >,
     F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
 {
-    type Request = A::Request;
     type Response = Res;
     type Error = Err;
-    type Service = AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>;
+    type Service = AndThenApplyFn<A::Service, B::Service, F, Fut, Req, Res, Err>;
     type Config = A::Config;
     type InitError = A::InitError;
-    type Future = AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>;
+    type Future = AndThenApplyFnFactoryResponse<A, B, F, Fut, Req, Res, Err>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         let srv = &*self.srv;
@@ -211,10 +218,14 @@ where
 }
 
 #[pin_project::pin_project]
-pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
+pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Req, Res, Err>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<
+        Result<A::Response, A::Error>,
+        Config = A::Config,
+        InitError = A::InitError,
+    >,
     F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error>,
@@ -229,16 +240,21 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
+impl<A, B, F, Fut, Req, Res, Err> Future
+    for AndThenApplyFnFactoryResponse<A, B, F, Fut, Req, Res, Err>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<
+        Result<A::Response, A::Error>,
+        Config = A::Config,
+        InitError = A::InitError,
+    >,
     F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
     Err: From<A::Error> + From<B::Error>,
 {
     type Output =
-        Result<AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>, A::InitError>;
+        Result<AndThenApplyFn<A::Service, B::Service, F, Fut, Req, Res, Err>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -280,8 +296,7 @@ mod tests {
 
     #[derive(Clone)]
     struct Srv;
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
@@ -291,16 +306,17 @@ mod tests {
         }
 
         #[allow(clippy::unit_arg)]
-        fn call(&mut self, req: Self::Request) -> Self::Future {
+        fn call(&mut self, req: ()) -> Self::Future {
             ok(req)
         }
     }
 
     #[actix_rt::test]
     async fn test_service() {
-        let mut srv = pipeline(ok).and_then_apply_fn(Srv, |req: &'static str, s| {
-            s.call(()).map_ok(move |res| (req, res))
-        });
+        let mut srv = pipeline(|| async { Ok(2) })
+            .and_then_apply_fn(Srv, |req: &'static str, s| {
+                s.call(()).map_ok(move |res| (req, res))
+            });
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Ok(())));
 
diff --git a/actix-service/src/apply.rs b/actix-service/src/apply.rs
index d1f8ff3a..b6f6ee07 100644
--- a/actix-service/src/apply.rs
+++ b/actix-service/src/apply.rs
@@ -6,43 +6,46 @@ use std::task::{Context, Poll};
 use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Apply transform function to a service.
-pub fn apply_fn<T, F, R, In, Out, Err, U>(service: U, f: F) -> Apply<T, F, R, In, Out, Err>
+pub fn apply_fn<T, Req, F, R, In, Out, Err, U>(
+    service: U,
+    f: F,
+) -> Apply<T, Req, F, R, In, Out, Err>
 where
-    T: Service<Error = Err>,
+    T: Service<Req, Error = Err>,
     F: FnMut(In, &mut T) -> R,
     R: Future<Output = Result<Out, Err>>,
-    U: IntoService<T>,
+    U: IntoService<T, Req>,
 {
     Apply::new(service.into_service(), f)
 }
 
 /// Service factory that produces `apply_fn` service.
-pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
+pub fn apply_fn_factory<T, Req, F, R, In, Out, Err, U>(
     service: U,
     f: F,
-) -> ApplyServiceFactory<T, F, R, In, Out, Err>
+) -> ApplyServiceFactory<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R + Clone,
     R: Future<Output = Result<Out, Err>>,
-    U: IntoServiceFactory<T>,
+    U: IntoServiceFactory<T, Req>,
 {
     ApplyServiceFactory::new(service.into_factory(), f)
 }
 
 /// `Apply` service combinator
-pub struct Apply<T, F, R, In, Out, Err>
+pub struct Apply<T, Req, F, R, In, Out, Err>
 where
-    T: Service<Error = Err>,
+    T: Service<Req, Error = Err>,
 {
     service: T,
     f: F,
     r: PhantomData<(In, Out, R)>,
 }
 
-impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> Apply<T, Req, F, R, In, Out, Err>
 where
-    T: Service<Error = Err>,
+    T: Service<Req, Error = Err>,
     F: FnMut(In, &mut T) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -56,9 +59,9 @@ where
     }
 }
 
-impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> Clone for Apply<T, Req, F, R, In, Out, Err>
 where
-    T: Service<Error = Err> + Clone,
+    T: Service<Req, Error = Err> + Clone,
     F: FnMut(In, &mut T) -> R + Clone,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -71,13 +74,13 @@ where
     }
 }
 
-impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> Service<Req> for Apply<T, Req, F, R, In, Out, Err>
 where
-    T: Service<Error = Err>,
+    T: Service<Req, Error = Err>,
     F: FnMut(In, &mut T) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
-    type Request = In;
+    // type Request = In;
     type Response = Out;
     type Error = Err;
     type Future = R;
@@ -92,9 +95,9 @@ where
 }
 
 /// `apply()` service factory
-pub struct ApplyServiceFactory<T, F, R, In, Out, Err>
+pub struct ApplyServiceFactory<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R + Clone,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -103,9 +106,9 @@ where
     r: PhantomData<(R, In, Out)>,
 }
 
-impl<T, F, R, In, Out, Err> ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> ApplyServiceFactory<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R + Clone,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -119,9 +122,9 @@ where
     }
 }
 
-impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err> + Clone,
+    T: ServiceFactory<Req, Error = Err> + Clone,
     F: FnMut(In, &mut T::Service) -> R + Clone,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -134,20 +137,21 @@ where
     }
 }
 
-impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> ServiceFactory<Req>
+    for ApplyServiceFactory<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R + Clone,
     R: Future<Output = Result<Out, Err>>,
 {
-    type Request = In;
+    // type Request = In;
     type Response = Out;
     type Error = Err;
 
     type Config = T::Config;
-    type Service = Apply<T::Service, F, R, In, Out, Err>;
+    type Service = Apply<T::Service, Req, F, R, In, Out, Err>;
     type InitError = T::InitError;
-    type Future = ApplyServiceFactoryResponse<T, F, R, In, Out, Err>;
+    type Future = ApplyServiceFactoryResponse<T,Req, F, R, In, Out, Err>;
 
     fn new_service(&self, cfg: T::Config) -> Self::Future {
         ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
@@ -155,9 +159,9 @@ where
 }
 
 #[pin_project::pin_project]
-pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+pub struct ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -167,9 +171,9 @@ where
     r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
@@ -182,13 +186,14 @@ where
     }
 }
 
-impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+impl<T, Req, F, R, In, Out, Err> Future
+    for ApplyServiceFactoryResponse<T, Req, F, R, In, Out, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    T: ServiceFactory<Req, Error = Err>,
     F: FnMut(In, &mut T::Service) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
-    type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
+    type Output = Result<Apply<T::Service, Req, F, R, In, Out, Err>, T::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -213,8 +218,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv;
 
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
diff --git a/actix-service/src/apply_cfg.rs b/actix-service/src/apply_cfg.rs
index 0d984309..61132ebb 100644
--- a/actix-service/src/apply_cfg.rs
+++ b/actix-service/src/apply_cfg.rs
@@ -8,12 +8,12 @@ use std::task::{Context, Poll};
 use crate::{Service, ServiceFactory};
 
 /// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
-pub fn apply_cfg<F, C, T, R, S, E>(
+pub fn apply_cfg<F, C, T, Req, R, S, E>(
     srv: T,
     f: F,
 ) -> impl ServiceFactory<
+    Req,
     Config = C,
-    Request = S::Request,
     Response = S::Response,
     Error = S::Error,
     Service = S,
@@ -22,9 +22,9 @@ pub fn apply_cfg<F, C, T, R, S, E>(
 > + Clone
 where
     F: FnMut(C, &mut T) -> R,
-    T: Service,
+    T: Service<Req>,
     R: Future<Output = Result<S, E>>,
-    S: Service,
+    S: Service<Req>,
 {
     ApplyConfigService {
         srv: Rc::new(RefCell::new((srv, f))),
@@ -35,12 +35,12 @@ where
 /// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
 ///
 /// Service1 get constructed from `T` factory.
-pub fn apply_cfg_factory<F, C, T, R, S>(
+pub fn apply_cfg_factory<F, C, Req, T, R, S>(
     factory: T,
     f: F,
 ) -> impl ServiceFactory<
+    Req,
     Config = C,
-    Request = S::Request,
     Response = S::Response,
     Error = S::Error,
     Service = S,
@@ -48,10 +48,10 @@ pub fn apply_cfg_factory<F, C, T, R, S>(
 > + Clone
 where
     F: FnMut(C, &mut T::Service) -> R,
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     ApplyConfigServiceFactory {
         srv: Rc::new(RefCell::new((factory, f))),
@@ -60,23 +60,23 @@ where
 }
 
 /// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
-struct ApplyConfigService<F, C, T, R, S, E>
+struct ApplyConfigService<F, C, Req, T, R, S, E>
 where
     F: FnMut(C, &mut T) -> R,
-    T: Service,
+    T: Service<Req>,
     R: Future<Output = Result<S, E>>,
-    S: Service,
+    S: Service<Req>,
 {
     srv: Rc<RefCell<(T, F)>>,
     _t: PhantomData<(C, R, S)>,
 }
 
-impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E>
+impl<F, C, Req, T, R, S, E> Clone for ApplyConfigService<F, C, Req, T, R, S, E>
 where
     F: FnMut(C, &mut T) -> R,
-    T: Service,
+    T: Service<Req>,
     R: Future<Output = Result<S, E>>,
-    S: Service,
+    S: Service<Req>,
 {
     fn clone(&self) -> Self {
         ApplyConfigService {
@@ -86,15 +86,14 @@ where
     }
 }
 
-impl<F, C, T, R, S, E> ServiceFactory for ApplyConfigService<F, C, T, R, S, E>
+impl<F, C, Req, T, R, S, E> ServiceFactory<Req> for ApplyConfigService<F, C, Req, T, R, S, E>
 where
     F: FnMut(C, &mut T) -> R,
-    T: Service,
+    T: Service<Req>,
     R: Future<Output = Result<S, E>>,
-    S: Service,
+    S: Service<Req>,
 {
     type Config = C;
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Service = S;
@@ -109,23 +108,23 @@ where
 }
 
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-struct ApplyConfigServiceFactory<F, C, T, R, S>
+struct ApplyConfigServiceFactory<F, C, Req, T, R, S>
 where
     F: FnMut(C, &mut T::Service) -> R,
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     srv: Rc<RefCell<(T, F)>>,
     _t: PhantomData<(C, R, S)>,
 }
 
-impl<F, C, T, R, S> Clone for ApplyConfigServiceFactory<F, C, T, R, S>
+impl<F, C, Req, T, R, S> Clone for ApplyConfigServiceFactory<F, C, Req, T, R, S>
 where
     F: FnMut(C, &mut T::Service) -> R,
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     fn clone(&self) -> Self {
         Self {
@@ -135,22 +134,21 @@ where
     }
 }
 
-impl<F, C, T, R, S> ServiceFactory for ApplyConfigServiceFactory<F, C, T, R, S>
+impl<F, C, Req, T, R, S> ServiceFactory<Req> for ApplyConfigServiceFactory<F, C, Req, T, R, S>
 where
     F: FnMut(C, &mut T::Service) -> R,
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     type Config = C;
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Service = S;
 
     type InitError = T::InitError;
-    type Future = ApplyConfigServiceFactoryResponse<F, C, T, R, S>;
+    type Future = ApplyConfigServiceFactoryResponse<F, C, Req, T, R, S>;
 
     fn new_service(&self, cfg: C) -> Self::Future {
         ApplyConfigServiceFactoryResponse {
@@ -162,40 +160,40 @@ where
 }
 
 #[pin_project::pin_project]
-struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
+struct ApplyConfigServiceFactoryResponse<F, C, Req, T, R, S>
 where
     F: FnMut(C, &mut T::Service) -> R,
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     cfg: Option<C>,
     store: Rc<RefCell<(T, F)>>,
     #[pin]
-    state: State<T, R, S>,
+    state: State<T, R, S, Req>,
 }
 
 #[pin_project::pin_project(project = StateProj)]
-enum State<T, R, S>
+enum State<T, R, S, Req>
 where
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     A(#[pin] T::Future),
     B(T::Service),
     C(#[pin] R),
 }
 
-impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S>
+impl<F, C, Req, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, Req, T, R, S>
 where
     F: FnMut(C, &mut T::Service) -> R,
-    T: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     type Output = Result<S, T::InitError>;
 
diff --git a/actix-service/src/boxed.rs b/actix-service/src/boxed.rs
index e630f81c..acf796b8 100644
--- a/actix-service/src/boxed.rs
+++ b/actix-service/src/boxed.rs
@@ -9,17 +9,17 @@ use crate::{Service, ServiceFactory};
 pub type BoxFuture<I, E> = Pin<Box<dyn Future<Output = Result<I, E>>>>;
 
 pub type BoxService<Req, Res, Err> =
-    Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
+    Box<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
 
-pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
+pub struct BoxServiceFactory<Cfg, Req, Res, Err, InitErr>(Inner<Cfg, Req, Res, Err, InitErr>);
 
 /// Create boxed service factory
-pub fn factory<T>(
+pub fn factory<T, Req>(
     factory: T,
-) -> BoxServiceFactory<T::Config, T::Request, T::Response, T::Error, T::InitError>
+) -> BoxServiceFactory<T::Config, Req, T::Response, T::Error, T::InitError>
 where
-    T: ServiceFactory + 'static,
-    T::Request: 'static,
+    T: ServiceFactory<Req> + 'static,
+    Req: 'static,
     T::Response: 'static,
     T::Service: 'static,
     T::Future: 'static,
@@ -33,18 +33,18 @@ where
 }
 
 /// Create boxed service
-pub fn service<T>(service: T) -> BoxService<T::Request, T::Response, T::Error>
+pub fn service<S, Req>(service: S) -> BoxService<Req, S::Response, S::Error>
 where
-    T: Service + 'static,
-    T::Future: 'static,
+    S: Service<Req> + 'static,
+    S::Future: 'static,
 {
     Box::new(ServiceWrapper(service))
 }
 
 type Inner<C, Req, Res, Err, InitErr> = Box<
     dyn ServiceFactory<
+        Req,
         Config = C,
-        Request = Req,
         Response = Res,
         Error = Err,
         InitError = InitErr,
@@ -53,14 +53,14 @@ type Inner<C, Req, Res, Err, InitErr> = Box<
     >,
 >;
 
-impl<C, Req, Res, Err, InitErr> ServiceFactory for BoxServiceFactory<C, Req, Res, Err, InitErr>
+impl<C, Req, Res, Err, InitErr> ServiceFactory<Req>
+    for BoxServiceFactory<C, Req, Res, Err, InitErr>
 where
     Req: 'static,
     Res: 'static,
     Err: 'static,
     InitErr: 'static,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type InitError = InitErr;
@@ -74,29 +74,22 @@ where
     }
 }
 
-struct FactoryWrapper<C, T: ServiceFactory> {
+struct FactoryWrapper<C, T: ServiceFactory<Req>, Req> {
     factory: T,
     _t: std::marker::PhantomData<C>,
 }
 
-impl<C, T, Req, Res, Err, InitErr> ServiceFactory for FactoryWrapper<C, T>
+impl<C, T, Req, Res, Err, InitErr> ServiceFactory<Req> for FactoryWrapper<C, T, Req>
 where
     Req: 'static,
     Res: 'static,
     Err: 'static,
     InitErr: 'static,
-    T: ServiceFactory<
-        Config = C,
-        Request = Req,
-        Response = Res,
-        Error = Err,
-        InitError = InitErr,
-    >,
+    T: ServiceFactory<Req, Config = C, Response = Res, Error = Err, InitError = InitErr>,
     T::Future: 'static,
     T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
+    <T::Service as Service<Req>>::Future: 'static,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type InitError = InitErr;
@@ -113,24 +106,23 @@ where
     }
 }
 
-struct ServiceWrapper<T: Service>(T);
+struct ServiceWrapper<S: Service<Req>, Req>(S);
 
-impl<T> ServiceWrapper<T>
+impl<S, Req> ServiceWrapper<S, Req>
 where
-    T: Service + 'static,
-    T::Future: 'static,
+    S: Service<Req> + 'static,
+    S::Future: 'static,
 {
-    fn boxed(service: T) -> BoxService<T::Request, T::Response, T::Error> {
+    fn boxed(service: S) -> BoxService<Req, S::Response, S::Error> {
         Box::new(ServiceWrapper(service))
     }
 }
 
-impl<T, Req, Res, Err> Service for ServiceWrapper<T>
+impl<T, Req, Res, Err> Service<Req> for ServiceWrapper<T, Req>
 where
-    T: Service<Request = Req, Response = Res, Error = Err>,
+    T: Service<Req, Response = Res, Error = Err>,
     T::Future: 'static,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = BoxFuture<Res, Err>;
@@ -139,7 +131,7 @@ where
         self.0.poll_ready(ctx)
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         Box::pin(self.0.call(req))
     }
 }
diff --git a/actix-service/src/fn_service.rs b/actix-service/src/fn_service.rs
index 08690a5d..5a2a1b60 100644
--- a/actix-service/src/fn_service.rs
+++ b/actix-service/src/fn_service.rs
@@ -53,9 +53,11 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
+pub fn fn_factory<F, Cfg, Srv, Req, Fut, Err>(
+    f: F,
+) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Req, Err>
 where
-    Srv: Service,
+    Srv: Service<Req>,
     F: Fn() -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
 {
@@ -92,13 +94,13 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Err>(
+pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Req, Err>(
     f: F,
-) -> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+) -> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     FnServiceConfig::new(f)
 }
@@ -132,12 +134,11 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err>
+impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Fut, Req, Res, Err>
 where
     F: FnMut(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = Fut;
@@ -151,7 +152,7 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>> for F
+impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>, Req> for F
 where
     F: FnMut(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
@@ -190,12 +191,11 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()>
+impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
     F: FnMut(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = Fut;
@@ -204,17 +204,17 @@ where
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
-impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory<Req>
+    for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
     F: FnMut(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
 
@@ -229,7 +229,7 @@ where
 }
 
 impl<F, Fut, Req, Res, Err, Cfg>
-    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>> for F
+    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>, Req> for F
 where
     F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
@@ -240,32 +240,32 @@ where
 }
 
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-pub struct FnServiceConfig<F, Fut, Cfg, Srv, Err>
+pub struct FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     f: F,
     _t: PhantomData<(Fut, Cfg, Srv, Err)>,
 }
 
-impl<F, Fut, Cfg, Srv, Err> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     fn new(f: F) -> Self {
         FnServiceConfig { f, _t: PhantomData }
     }
 }
 
-impl<F, Fut, Cfg, Srv, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut + Clone,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     fn clone(&self) -> Self {
         FnServiceConfig {
@@ -275,13 +275,13 @@ where
     }
 }
 
-impl<F, Fut, Cfg, Srv, Err> ServiceFactory for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req>
+    for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
-    type Request = Srv::Request;
     type Response = Srv::Response;
     type Error = Srv::Error;
 
@@ -296,64 +296,65 @@ where
 }
 
 /// Converter for `Fn() -> Future<Service>` fn
-pub struct FnServiceNoConfig<F, C, S, R, E>
+pub struct FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
-    S: Service,
-    R: Future<Output = Result<S, E>>,
+    F: Fn() -> Fut,
+    Srv: Service<Req>,
+    Fut: Future<Output = Result<Srv, Err>>,
 {
     f: F,
-    _t: PhantomData<C>,
+    _t: PhantomData<Cfg>,
 }
 
-impl<F, C, S, R, E> FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
     fn new(f: F) -> Self {
         Self { f, _t: PhantomData }
     }
 }
 
-impl<F, C, S, R, E> ServiceFactory for FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> ServiceFactory<Req>
+    for FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Service = S;
-    type Config = C;
-    type InitError = E;
-    type Future = R;
+    type Response = Srv::Response;
+    type Error = Srv::Error;
+    type Service = Srv;
+    type Config = Cfg;
+    type InitError = Err;
+    type Future = Fut;
 
-    fn new_service(&self, _: C) -> Self::Future {
+    fn new_service(&self, _: Cfg) -> Self::Future {
         (self.f)()
     }
 }
 
-impl<F, C, S, R, E> Clone for FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> Clone for FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R + Clone,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut + Clone,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
 
-impl<F, C, S, R, E> IntoServiceFactory<FnServiceNoConfig<F, C, S, R, E>> for F
+impl<F, Cfg, Srv, Req, Fut, Err>
+    IntoServiceFactory<FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>, Req> for F
 where
-    F: Fn() -> R,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
-    fn into_factory(self) -> FnServiceNoConfig<F, C, S, R, E> {
+    fn into_factory(self) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err> {
         FnServiceNoConfig::new(self)
     }
 }
diff --git a/actix-service/src/lib.rs b/actix-service/src/lib.rs
index 96c878e3..6067595c 100644
--- a/actix-service/src/lib.rs
+++ b/actix-service/src/lib.rs
@@ -72,14 +72,11 @@ pub use self::transform::{apply, Transform};
 /// ```rust,ignore
 /// async fn my_service(req: u8) -> Result<u64, MyError>;
 /// ```
-pub trait Service {
-    /// Requests handled by the service.
-    type Request;
-
+pub trait Service<Req> {
     /// Responses given by the service.
     type Response;
 
-    /// Errors produced by the service.
+    /// Errors produced by the service when polling readiness or executing call.
     type Error;
 
     /// The future response value.
@@ -109,7 +106,7 @@ pub trait Service {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Self::Request) -> Self::Future;
+    fn call(&mut self, req: Req) -> Self::Future;
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
@@ -120,7 +117,7 @@ pub trait Service {
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it, similar to the existing `map` methods in the
     /// standard library.
-    fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
+    fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, Req, R>
     where
         Self: Sized,
         F: FnMut(Self::Response) -> R,
@@ -136,7 +133,7 @@ pub trait Service {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
+    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
@@ -154,10 +151,7 @@ pub trait Service {
 /// requests on that new TCP stream.
 ///
 /// `Config` is a service factory configuration type.
-pub trait ServiceFactory {
-    /// Requests handled by the created services.
-    type Request;
-
+pub trait ServiceFactory<Req> {
     /// Responses given by the created services.
     type Response;
 
@@ -168,11 +162,7 @@ pub trait ServiceFactory {
     type Config;
 
     /// The kind of `Service` created by this factory.
-    type Service: Service<
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
+    type Service: Service<Req, Response = Self::Response, Error = Self::Error>;
 
     /// Errors potentially raised while building a service.
     type InitError;
@@ -185,7 +175,7 @@ pub trait ServiceFactory {
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
-    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
+    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, Req, R>
     where
         Self: Sized,
         F: FnMut(Self::Response) -> R + Clone,
@@ -194,7 +184,7 @@ pub trait ServiceFactory {
     }
 
     /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
+    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E + Clone,
@@ -203,7 +193,7 @@ pub trait ServiceFactory {
     }
 
     /// Map this factory's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
+    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, Req, E>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E + Clone,
@@ -212,11 +202,10 @@ pub trait ServiceFactory {
     }
 }
 
-impl<'a, S> Service for &'a mut S
+impl<'a, S, Req> Service<Req> for &'a mut S
 where
-    S: Service + 'a,
+    S: Service<Req> + 'a,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -225,16 +214,15 @@ where
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for Box<S>
+impl<S, Req> Service<Req> for Box<S>
 where
-    S: Service + ?Sized,
+    S: Service<Req> + ?Sized,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -243,16 +231,15 @@ where
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for RefCell<S>
+impl<S, Req> Service<Req> for RefCell<S>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -261,16 +248,15 @@ where
         self.borrow_mut().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         self.borrow_mut().call(request)
     }
 }
 
-impl<S> Service for Rc<RefCell<S>>
+impl<S, Req> Service<Req> for Rc<RefCell<S>>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -279,16 +265,15 @@ where
         self.borrow_mut().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (&mut (**self).borrow_mut()).call(request)
     }
 }
 
-impl<S> ServiceFactory for Rc<S>
+impl<S, Req> ServiceFactory<Req> for Rc<S>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Config = S::Config;
@@ -301,11 +286,10 @@ where
     }
 }
 
-impl<S> ServiceFactory for Arc<S>
+impl<S, Req> ServiceFactory<Req> for Arc<S>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Config = S::Config;
@@ -319,35 +303,35 @@ where
 }
 
 /// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
+pub trait IntoService<T, Req>
 where
-    T: Service,
+    T: Service<Req>,
 {
     /// Convert to a `Service`
     fn into_service(self) -> T;
 }
 
 /// Trait for types that can be converted to a `ServiceFactory`
-pub trait IntoServiceFactory<T>
+pub trait IntoServiceFactory<T, Req>
 where
-    T: ServiceFactory,
+    T: ServiceFactory<Req>,
 {
     /// Convert `Self` to a `ServiceFactory`
     fn into_factory(self) -> T;
 }
 
-impl<T> IntoService<T> for T
+impl<T, Req> IntoService<T, Req> for T
 where
-    T: Service,
+    T: Service<Req>,
 {
     fn into_service(self) -> T {
         self
     }
 }
 
-impl<T> IntoServiceFactory<T> for T
+impl<T, Req> IntoServiceFactory<T, Req> for T
 where
-    T: ServiceFactory,
+    T: ServiceFactory<Req>,
 {
     fn into_factory(self) -> T {
         self
@@ -355,10 +339,10 @@ where
 }
 
 /// Convert object of type `T` to a service `S`
-pub fn into_service<T, S>(tp: T) -> S
+pub fn into_service<T, S, Req>(tp: T) -> S
 where
-    S: Service,
-    T: IntoService<S>,
+    S: Service<Req>,
+    T: IntoService<S, Req>,
 {
     tp.into_service()
 }
diff --git a/actix-service/src/map.rs b/actix-service/src/map.rs
index ec3520a1..05a9401a 100644
--- a/actix-service/src/map.rs
+++ b/actix-service/src/map.rs
@@ -8,18 +8,18 @@ use super::{Service, ServiceFactory};
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
 /// This is created by the `ServiceExt::map` method.
-pub struct Map<A, F, Response> {
+pub struct Map<A, F, Req, Res> {
     service: A,
     f: F,
-    _t: PhantomData<Response>,
+    _t: PhantomData<(Req, Res)>,
 }
 
-impl<A, F, Response> Map<A, F, Response> {
+impl<A, F, Req, Res> Map<A, F, Req, Res> {
     /// Create new `Map` combinator
     pub(crate) fn new(service: A, f: F) -> Self
     where
-        A: Service,
-        F: FnMut(A::Response) -> Response,
+        A: Service<Req>,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             service,
@@ -29,7 +29,7 @@ impl<A, F, Response> Map<A, F, Response> {
     }
 }
 
-impl<A, F, Response> Clone for Map<A, F, Response>
+impl<A, F, Req, Res> Clone for Map<A, F, Req, Res>
 where
     A: Clone,
     F: Clone,
@@ -43,52 +43,51 @@ where
     }
 }
 
-impl<A, F, Response> Service for Map<A, F, Response>
+impl<A, F, Req, Res> Service<Req> for Map<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response + Clone,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
-    type Response = Response;
+    type Response = Res;
     type Error = A::Error;
-    type Future = MapFuture<A, F, Response>;
+    type Future = MapFuture<A, F, Req, Res>;
 
     fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx)
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
 #[pin_project::pin_project]
-pub struct MapFuture<A, F, Response>
+pub struct MapFuture<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res,
 {
     f: F,
     #[pin]
     fut: A::Future,
 }
 
-impl<A, F, Response> MapFuture<A, F, Response>
+impl<A, F, Req, Res> MapFuture<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, Response> Future for MapFuture<A, F, Response>
+impl<A, F, Req, Res> Future for MapFuture<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res,
 {
-    type Output = Result<Response, A::Error>;
+    type Output = Result<Res, A::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -102,17 +101,17 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapServiceFactory<A, F, Res> {
+pub struct MapServiceFactory<A, F, Req, Res> {
     a: A,
     f: F,
     r: PhantomData<Res>,
 }
 
-impl<A, F, Res> MapServiceFactory<A, F, Res> {
+impl<A, F, Req, Res> MapServiceFactory<A, F, Req, Res> {
     /// Create new `Map` new service instance
     pub(crate) fn new(a: A, f: F) -> Self
     where
-        A: ServiceFactory,
+        A: ServiceFactory<Req>,
         F: FnMut(A::Response) -> Res,
     {
         Self {
@@ -123,7 +122,7 @@ impl<A, F, Res> MapServiceFactory<A, F, Res> {
     }
 }
 
-impl<A, F, Res> Clone for MapServiceFactory<A, F, Res>
+impl<A, F, Req, Res> Clone for MapServiceFactory<A, F, Req, Res>
 where
     A: Clone,
     F: Clone,
@@ -137,19 +136,18 @@ where
     }
 }
 
-impl<A, F, Res> ServiceFactory for MapServiceFactory<A, F, Res>
+impl<A, F, Req, Res> ServiceFactory<Req> for MapServiceFactory<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
     type Response = Res;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = Map<A::Service, F, Res>;
+    type Service = Map<A::Service, F, Req, Res>;
     type InitError = A::InitError;
-    type Future = MapServiceFuture<A, F, Res>;
+    type Future = MapServiceFuture<A, F, Req, Res>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
@@ -157,9 +155,9 @@ where
 }
 
 #[pin_project::pin_project]
-pub struct MapServiceFuture<A, F, Res>
+pub struct MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
     #[pin]
@@ -167,9 +165,9 @@ where
     f: Option<F>,
 }
 
-impl<A, F, Res> MapServiceFuture<A, F, Res>
+impl<A, F, Req, Res> MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -177,12 +175,12 @@ where
     }
 }
 
-impl<A, F, Res> Future for MapServiceFuture<A, F, Res>
+impl<A, F, Req, Res> Future for MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
-    type Output = Result<Map<A::Service, F, Res>, A::InitError>;
+    type Output = Result<Map<A::Service, F, Req, Res>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -204,8 +202,7 @@ mod tests {
 
     struct Srv;
 
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
diff --git a/actix-service/src/map_config.rs b/actix-service/src/map_config.rs
index 7a1a1b89..93abf49e 100644
--- a/actix-service/src/map_config.rs
+++ b/actix-service/src/map_config.rs
@@ -6,37 +6,37 @@ use super::{IntoServiceFactory, ServiceFactory};
 ///
 /// Note that this function consumes the receiving service factory and returns
 /// a wrapped version of it.
-pub fn map_config<T, U, F, C>(factory: U, f: F) -> MapConfig<T, F, C>
+pub fn map_config<T, U, F, C, Req>(factory: U, f: F) -> MapConfig<T, Req, F, C>
 where
-    T: ServiceFactory,
-    U: IntoServiceFactory<T>,
+    T: ServiceFactory<Req>,
+    U: IntoServiceFactory<T, Req>,
     F: Fn(C) -> T::Config,
 {
     MapConfig::new(factory.into_factory(), f)
 }
 
 /// Replace config with unit
-pub fn unit_config<T, U, C>(factory: U) -> UnitConfig<T, C>
+pub fn unit_config<T, U, C, Req>(factory: U) -> UnitConfig<T, C, Req>
 where
-    T: ServiceFactory<Config = ()>,
-    U: IntoServiceFactory<T>,
+    T: ServiceFactory<Req, Config = ()>,
+    U: IntoServiceFactory<T, Req>,
 {
     UnitConfig::new(factory.into_factory())
 }
 
 /// `map_config()` adapter service factory
-pub struct MapConfig<A, F, C> {
+pub struct MapConfig<A, Req, F, C> {
     a: A,
     f: F,
-    e: PhantomData<C>,
+    e: PhantomData<(C, Req)>,
 }
 
-impl<A, F, C> MapConfig<A, F, C> {
+impl<T, F, C, Req> MapConfig<T, F, C, Req> {
     /// Create new `MapConfig` combinator
-    pub(crate) fn new(a: A, f: F) -> Self
+    pub(crate) fn new(a: T, f: F) -> Self
     where
-        A: ServiceFactory,
-        F: Fn(C) -> A::Config,
+        T: ServiceFactory<Req>,
+        F: Fn(C) -> T::Config,
     {
         Self {
             a,
@@ -46,9 +46,9 @@ impl<A, F, C> MapConfig<A, F, C> {
     }
 }
 
-impl<A, F, C> Clone for MapConfig<A, F, C>
+impl<T, Req, F, C> Clone for MapConfig<T, Req, F, C>
 where
-    A: Clone,
+    T: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
@@ -60,19 +60,18 @@ where
     }
 }
 
-impl<A, F, C> ServiceFactory for MapConfig<A, F, C>
+impl<T, Req, F, C> ServiceFactory<Req> for MapConfig<T, Req, F, C>
 where
-    A: ServiceFactory,
-    F: Fn(C) -> A::Config,
+    T: ServiceFactory<Req>,
+    F: Fn(C) -> T::Config,
 {
-    type Request = A::Request;
-    type Response = A::Response;
-    type Error = A::Error;
+    type Response = T::Response;
+    type Error = T::Error;
 
     type Config = C;
-    type Service = A::Service;
-    type InitError = A::InitError;
-    type Future = A::Future;
+    type Service = T::Service;
+    type InitError = T::InitError;
+    type Future = T::Future;
 
     fn new_service(&self, cfg: C) -> Self::Future {
         self.a.new_service((self.f)(cfg))
@@ -80,24 +79,24 @@ where
 }
 
 /// `unit_config()` config combinator
-pub struct UnitConfig<A, C> {
-    a: A,
-    e: PhantomData<C>,
+pub struct UnitConfig<T, C, Req> {
+    a: T,
+    e: PhantomData<(C, Req)>,
 }
 
-impl<A, C> UnitConfig<A, C>
+impl<T, C, Req> UnitConfig<T, C, Req>
 where
-    A: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
 {
     /// Create new `UnitConfig` combinator
-    pub(crate) fn new(a: A) -> Self {
+    pub(crate) fn new(a: T) -> Self {
         Self { a, e: PhantomData }
     }
 }
 
-impl<A, C> Clone for UnitConfig<A, C>
+impl<T, C, Req> Clone for UnitConfig<T, C, Req>
 where
-    A: Clone,
+    T: Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -107,18 +106,17 @@ where
     }
 }
 
-impl<A, C> ServiceFactory for UnitConfig<A, C>
+impl<T, C, Req> ServiceFactory<Req> for UnitConfig<T, C, Req>
 where
-    A: ServiceFactory<Config = ()>,
+    T: ServiceFactory<Req, Config = ()>,
 {
-    type Request = A::Request;
-    type Response = A::Response;
-    type Error = A::Error;
+    type Response = T::Response;
+    type Error = T::Error;
 
     type Config = C;
-    type Service = A::Service;
-    type InitError = A::InitError;
-    type Future = A::Future;
+    type Service = T::Service;
+    type InitError = T::InitError;
+    type Future = T::Future;
 
     fn new_service(&self, _: C) -> Self::Future {
         self.a.new_service(())
diff --git a/actix-service/src/map_err.rs b/actix-service/src/map_err.rs
index ee7145c3..970cf714 100644
--- a/actix-service/src/map_err.rs
+++ b/actix-service/src/map_err.rs
@@ -9,18 +9,18 @@ use super::{Service, ServiceFactory};
 /// error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
-pub struct MapErr<A, F, E> {
-    service: A,
+pub struct MapErr<S, Req, F, E> {
+    service: S,
     f: F,
     _t: PhantomData<E>,
 }
 
-impl<A, F, E> MapErr<A, F, E> {
+impl<S, Req, F, E> MapErr<S, Req, F, E> {
     /// Create new `MapErr` combinator
-    pub(crate) fn new(service: A, f: F) -> Self
+    pub(crate) fn new(service: S, f: F) -> Self
     where
-        A: Service,
-        F: Fn(A::Error) -> E,
+        S: Service<Req>,
+        F: Fn(S::Error) -> E,
     {
         Self {
             service,
@@ -30,9 +30,9 @@ impl<A, F, E> MapErr<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapErr<A, F, E>
+impl<S, Req, F, E> Clone for MapErr<S, Req, F, E>
 where
-    A: Clone,
+    S: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
@@ -44,29 +44,28 @@ where
     }
 }
 
-impl<A, F, E> Service for MapErr<A, F, E>
+impl<A, Req, F, E> Service<Req> for MapErr<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, E>;
+    type Future = MapErrFuture<A, Req, F, E>;
 
     fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx).map_err(&self.f)
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
 #[pin_project::pin_project]
-pub struct MapErrFuture<A, F, E>
+pub struct MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     f: F,
@@ -74,9 +73,9 @@ where
     fut: A::Future,
 }
 
-impl<A, F, E> MapErrFuture<A, F, E>
+impl<A, Req, F, E> MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -84,9 +83,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrFuture<A, F, E>
+impl<A, Req, F, E> Future for MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     type Output = Result<A::Response, E>;
@@ -101,9 +100,9 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrServiceFactory<A, F, E>
+pub struct MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
     a: A,
@@ -111,9 +110,9 @@ where
     e: PhantomData<E>,
 }
 
-impl<A, F, E> MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
     /// Create new `MapErr` new service instance
@@ -126,9 +125,9 @@ where
     }
 }
 
-impl<A, F, E> Clone for MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> Clone for MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory + Clone,
+    A: ServiceFactory<Req> + Clone,
     F: Fn(A::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
@@ -140,19 +139,18 @@ where
     }
 }
 
-impl<A, F, E> ServiceFactory for MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> ServiceFactory<Req> for MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
 
     type Config = A::Config;
-    type Service = MapErr<A::Service, F, E>;
+    type Service = MapErr<A::Service, Req, F, E>;
     type InitError = A::InitError;
-    type Future = MapErrServiceFuture<A, F, E>;
+    type Future = MapErrServiceFuture<A, Req, F, E>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
@@ -160,9 +158,9 @@ where
 }
 
 #[pin_project::pin_project]
-pub struct MapErrServiceFuture<A, F, E>
+pub struct MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E,
 {
     #[pin]
@@ -170,9 +168,9 @@ where
     f: F,
 }
 
-impl<A, F, E> MapErrServiceFuture<A, F, E>
+impl<A, Req, F, E> MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -180,12 +178,12 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrServiceFuture<A, F, E>
+impl<A, Req, F, E> Future for MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
+    type Output = Result<MapErr<A::Service, Req, F, E>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -206,8 +204,7 @@ mod tests {
 
     struct Srv;
 
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
diff --git a/actix-service/src/map_init_err.rs b/actix-service/src/map_init_err.rs
index b1eec072..f71f3add 100644
--- a/actix-service/src/map_init_err.rs
+++ b/actix-service/src/map_init_err.rs
@@ -6,16 +6,16 @@ use std::task::{Context, Poll};
 use super::ServiceFactory;
 
 /// `MapInitErr` service combinator
-pub struct MapInitErr<A, F, E> {
+pub struct MapInitErr<A, F, Req, Err> {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(Req, Err)>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E>
+impl<A, Req, F, Err> MapInitErr<A, Req, F, Err>
 where
-    A: ServiceFactory,
-    F: Fn(A::InitError) -> E,
+    A: ServiceFactory<Req>,
+    F: Fn(A::InitError) -> Err,
 {
     /// Create new `MapInitErr` combinator
     pub(crate) fn new(a: A, f: F) -> Self {
@@ -27,7 +27,7 @@ where
     }
 }
 
-impl<A, F, E> Clone for MapInitErr<A, F, E>
+impl<A, F, Req, E> Clone for MapInitErr<A, F, Req, E>
 where
     A: Clone,
     F: Clone,
@@ -41,19 +41,18 @@ where
     }
 }
 
-impl<A, F, E> ServiceFactory for MapInitErr<A, F, E>
+impl<A, Req, F, E> ServiceFactory<Req> for MapInitErr<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
 
     type Config = A::Config;
     type Service = A::Service;
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    type Future = MapInitErrFuture<A, Req, F, E>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
@@ -61,9 +60,9 @@ where
 }
 
 #[pin_project::pin_project]
-pub struct MapInitErrFuture<A, F, E>
+pub struct MapInitErrFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     f: F,
@@ -71,9 +70,9 @@ where
     fut: A::Future,
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, Req, F, E> MapInitErrFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -81,9 +80,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
+impl<A, Req, F, E> Future for MapInitErrFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     type Output = Result<A::Service, E>;
diff --git a/actix-service/src/pipeline.rs b/actix-service/src/pipeline.rs
index 75cd6af9..31ad705a 100644
--- a/actix-service/src/pipeline.rs
+++ b/actix-service/src/pipeline.rs
@@ -1,5 +1,5 @@
-use std::future::Future;
 use std::task::{Context, Poll};
+use std::{future::Future, marker::PhantomData};
 
 use crate::and_then::{AndThenService, AndThenServiceFactory};
 use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
@@ -10,33 +10,36 @@ use crate::then::{ThenService, ThenServiceFactory};
 use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Construct new pipeline with one service in pipeline chain.
-pub fn pipeline<F, T>(service: F) -> Pipeline<T>
+pub fn pipeline<F, T, Req>(service: F) -> Pipeline<T, Req>
 where
-    F: IntoService<T>,
-    T: Service,
+    F: IntoService<T, Req>,
+    T: Service<Req>,
 {
     Pipeline {
         service: service.into_service(),
+        _phantom: PhantomData,
     }
 }
 
 /// Construct new pipeline factory with one service factory.
-pub fn pipeline_factory<T, F>(factory: F) -> PipelineFactory<T>
+pub fn pipeline_factory<T, F, Req>(factory: F) -> PipelineFactory<T, Req>
 where
-    T: ServiceFactory,
-    F: IntoServiceFactory<T>,
+    T: ServiceFactory<Req>,
+    F: IntoServiceFactory<T, Req>,
 {
     PipelineFactory {
         factory: factory.into_factory(),
+        _phantom: PhantomData,
     }
 }
 
 /// Pipeline service - pipeline allows to compose multiple service into one service.
-pub struct Pipeline<T> {
+pub struct Pipeline<T, Req> {
     service: T,
+    _phantom: PhantomData<Req>,
 }
 
-impl<T: Service> Pipeline<T> {
+impl<T: Service<Req>, Req> Pipeline<T, Req> {
     /// Call another service after call to this one has resolved successfully.
     ///
     /// This function can be used to chain two services together and ensure that
@@ -49,16 +52,15 @@ impl<T: Service> Pipeline<T> {
     pub fn and_then<F, U>(
         self,
         service: F,
-    ) -> Pipeline<
-        impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone,
-    >
+    ) -> Pipeline<impl Service<Req, Response = U::Response, Error = T::Error> + Clone, Req>
     where
         Self: Sized,
-        F: IntoService<U>,
-        U: Service<Request = T::Response, Error = T::Error>,
+        F: IntoService<U, Req>,
+        U: Service<T::Response, Error = T::Error>,
     {
         Pipeline {
             service: AndThenService::new(self.service, service.into_service()),
+            _phantom: PhantomData,
         }
     }
 
@@ -70,17 +72,18 @@ impl<T: Service> Pipeline<T> {
         self,
         service: I,
         f: F,
-    ) -> Pipeline<impl Service<Request = T::Request, Response = Res, Error = Err> + Clone>
+    ) -> Pipeline<impl Service<Req, Response = Res, Error = Err> + Clone, Req>
     where
         Self: Sized,
-        I: IntoService<U>,
-        U: Service,
+        I: IntoService<U, Req>,
+        U: Service<Req>,
         F: FnMut(T::Response, &mut U) -> Fut,
         Fut: Future<Output = Result<Res, Err>>,
         Err: From<T::Error> + From<U::Error>,
     {
         Pipeline {
             service: AndThenApplyFn::new(self.service, service.into_service(), f),
+            _phantom: PhantomData,
         }
     }
 
@@ -92,16 +95,15 @@ impl<T: Service> Pipeline<T> {
     pub fn then<F, U>(
         self,
         service: F,
-    ) -> Pipeline<
-        impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone,
-    >
+    ) -> Pipeline<impl Service<Req, Response = U::Response, Error = T::Error> + Clone, Req>
     where
         Self: Sized,
-        F: IntoService<U>,
-        U: Service<Request = Result<T::Response, T::Error>, Error = T::Error>,
+        F: IntoService<U, Req>,
+        U: Service<Result<T::Response, T::Error>, Error = T::Error>,
     {
         Pipeline {
             service: ThenService::new(self.service, service.into_service()),
+            _phantom: PhantomData,
         }
     }
 
@@ -114,13 +116,14 @@ impl<T: Service> Pipeline<T> {
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it, similar to the existing `map` methods in the
     /// standard library.
-    pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, R>>
+    pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, Req, R>, Req>
     where
         Self: Sized,
         F: FnMut(T::Response) -> R,
     {
         Pipeline {
             service: Map::new(self.service, f),
+            _phantom: PhantomData,
         }
     }
 
@@ -132,30 +135,31 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>>
+    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, Req, F, E>, Req>
     where
         Self: Sized,
         F: Fn(T::Error) -> E,
     {
         Pipeline {
             service: MapErr::new(self.service, f),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T> Clone for Pipeline<T>
+impl<T, Req> Clone for Pipeline<T, Req>
 where
     T: Clone,
 {
     fn clone(&self) -> Self {
         Pipeline {
             service: self.service.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T: Service> Service for Pipeline<T> {
-    type Request = T::Request;
+impl<T: Service<Req>, Req> Service<Req> for Pipeline<T, Req> {
     type Response = T::Response;
     type Error = T::Error;
     type Future = T::Future;
@@ -166,17 +170,18 @@ impl<T: Service> Service for Pipeline<T> {
     }
 
     #[inline]
-    fn call(&mut self, req: T::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         self.service.call(req)
     }
 }
 
 /// Pipeline factory
-pub struct PipelineFactory<T> {
+pub struct PipelineFactory<T, Req> {
     factory: T,
+    _phantom: PhantomData<Req>,
 }
 
-impl<T: ServiceFactory> PipelineFactory<T> {
+impl<T: ServiceFactory<Req>, Req> PipelineFactory<T, Req> {
     /// Call another service after call to this one has resolved successfully.
     pub fn and_then<F, U>(
         self,
@@ -194,20 +199,22 @@ impl<T: ServiceFactory> PipelineFactory<T> {
                     Error = T::Error,
                 > + Clone,
             > + Clone,
+        Req,
     >
     where
         Self: Sized,
         T::Config: Clone,
-        F: IntoServiceFactory<U>,
+        F: IntoServiceFactory<U, Req>,
         U: ServiceFactory<
+            T::Response,
             Config = T::Config,
-            Request = T::Response,
             Error = T::Error,
             InitError = T::InitError,
         >,
     {
         PipelineFactory {
             factory: AndThenServiceFactory::new(self.factory, factory.into_factory()),
+            _phantom: PhantomData,
         }
     }
 
@@ -228,18 +235,20 @@ impl<T: ServiceFactory> PipelineFactory<T> {
                 InitError = T::InitError,
                 Service = impl Service<Request = T::Request, Response = Res, Error = Err> + Clone,
             > + Clone,
+        Req,
     >
     where
         Self: Sized,
         T::Config: Clone,
-        I: IntoServiceFactory<U>,
-        U: ServiceFactory<Config = T::Config, InitError = T::InitError>,
+        I: IntoServiceFactory<U, Req>,
+        U: ServiceFactory<Req, Config = T::Config, InitError = T::InitError>,
         F: FnMut(T::Response, &mut U::Service) -> Fut + Clone,
         Fut: Future<Output = Result<Res, Err>>,
         Err: From<T::Error> + From<U::Error>,
     {
         PipelineFactory {
             factory: AndThenApplyFnFactory::new(self.factory, factory.into_factory(), f),
+            _phantom: PhantomData,
         }
     }
 
@@ -265,72 +274,77 @@ impl<T: ServiceFactory> PipelineFactory<T> {
                     Error = T::Error,
                 > + Clone,
             > + Clone,
+        Req,
     >
     where
         Self: Sized,
         T::Config: Clone,
-        F: IntoServiceFactory<U>,
+        F: IntoServiceFactory<U, Req>,
         U: ServiceFactory<
+            Result<T::Response, T::Error>,
             Config = T::Config,
-            Request = Result<T::Response, T::Error>,
             Error = T::Error,
             InitError = T::InitError,
         >,
     {
         PipelineFactory {
             factory: ThenServiceFactory::new(self.factory, factory.into_factory()),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
-    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<T, F, R>>
+    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<T, F, Req, R>, Req>
     where
         Self: Sized,
         F: FnMut(T::Response) -> R + Clone,
     {
         PipelineFactory {
             factory: MapServiceFactory::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this service's error to a different error, returning a new service.
-    pub fn map_err<F, E>(self, f: F) -> PipelineFactory<MapErrServiceFactory<T, F, E>>
+    pub fn map_err<F, E>(self, f: F) -> PipelineFactory<MapErrServiceFactory<T, Req, F, E>, Req>
     where
         Self: Sized,
         F: Fn(T::Error) -> E + Clone,
     {
         PipelineFactory {
             factory: MapErrServiceFactory::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this factory's init error to a different error, returning a new service.
-    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, E>>
+    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, Req, E>, Req>
     where
         Self: Sized,
         F: Fn(T::InitError) -> E + Clone,
     {
         PipelineFactory {
             factory: MapInitErr::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T> Clone for PipelineFactory<T>
+impl<T, Req> Clone for PipelineFactory<T, Req>
 where
     T: Clone,
 {
     fn clone(&self) -> Self {
         PipelineFactory {
             factory: self.factory.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T: ServiceFactory> ServiceFactory for PipelineFactory<T> {
+impl<T: ServiceFactory<Req>, Req> ServiceFactory<Req> for PipelineFactory<T, Req> {
     type Config = T::Config;
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type Service = T::Service;
diff --git a/actix-service/src/then.rs b/actix-service/src/then.rs
index 3da46cbb..021e5484 100644
--- a/actix-service/src/then.rs
+++ b/actix-service/src/then.rs
@@ -1,8 +1,8 @@
-use std::cell::RefCell;
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
+use std::{cell::RefCell, marker::PhantomData};
 
 use super::{Service, ServiceFactory};
 
@@ -10,34 +10,33 @@ use super::{Service, ServiceFactory};
 /// another service.
 ///
 /// This is created by the `Pipeline::then` method.
-pub(crate) struct ThenService<A, B>(Rc<RefCell<(A, B)>>);
+pub(crate) struct ThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
 
-impl<A, B> ThenService<A, B> {
+impl<A, B, Req> ThenService<A, B, Req> {
     /// Create new `.then()` combinator
-    pub(crate) fn new(a: A, b: B) -> ThenService<A, B>
+    pub(crate) fn new(a: A, b: B) -> ThenService<A, B, Req>
     where
-        A: Service,
-        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+        A: Service<Req>,
+        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))))
+        Self(Rc::new(RefCell::new((a, b))), PhantomData)
     }
 }
 
-impl<A, B> Clone for ThenService<A, B> {
+impl<A, B, Req> Clone for ThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        ThenService(self.0.clone())
+        ThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B> Service for ThenService<A, B>
+impl<A, B, Req> Service<Req> for ThenService<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = B::Error;
-    type Future = ThenServiceResponse<A, B>;
+    type Future = ThenServiceResponse<A, B, Req>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         let mut srv = self.0.borrow_mut();
@@ -49,7 +48,7 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         ThenServiceResponse {
             state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())),
         }
@@ -57,30 +56,30 @@ where
 }
 
 #[pin_project::pin_project]
-pub(crate) struct ThenServiceResponse<A, B>
+pub(crate) struct ThenServiceResponse<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     #[pin]
-    state: State<A, B>,
+    state: State<A, B, Req>,
 }
 
 #[pin_project::pin_project(project = StateProj)]
-enum State<A, B>
+enum State<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
     B(#[pin] B::Future),
     Empty,
 }
 
-impl<A, B> Future for ThenServiceResponse<A, B>
+impl<A, B, Req> Future for ThenServiceResponse<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     type Output = Result<B::Response, B::Error>;
 
@@ -110,44 +109,43 @@ where
 }
 
 /// `.then()` service factory combinator
-pub(crate) struct ThenServiceFactory<A, B>(Rc<(A, B)>);
+pub(crate) struct ThenServiceFactory<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
-impl<A, B> ThenServiceFactory<A, B>
+impl<A, B, Req> ThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
     /// Create new `AndThen` combinator
     pub(crate) fn new(a: A, b: B) -> Self {
-        Self(Rc::new((a, b)))
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
-impl<A, B> ServiceFactory for ThenServiceFactory<A, B>
+impl<A, B, Req> ServiceFactory<Req> for ThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = ThenService<A::Service, B::Service>;
+    type Service = ThenService<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = ThenServiceFactoryResponse<A, B>;
+    type Future = ThenServiceFactoryResponse<A, B, Req>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         let srv = &*self.0;
@@ -155,19 +153,19 @@ where
     }
 }
 
-impl<A, B> Clone for ThenServiceFactory<A, B> {
+impl<A, B, Req> Clone for ThenServiceFactory<A, B, Req> {
     fn clone(&self) -> Self {
-        Self(self.0.clone())
+        Self(self.0.clone(), PhantomData)
     }
 }
 
 #[pin_project::pin_project]
-pub(crate) struct ThenServiceFactoryResponse<A, B>
+pub(crate) struct ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -180,12 +178,12 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> ThenServiceFactoryResponse<A, B>
+impl<A, B, Req> ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -200,17 +198,17 @@ where
     }
 }
 
-impl<A, B> Future for ThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Future for ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Output = Result<ThenService<A::Service, B::Service>, A::InitError>;
+    type Output = Result<ThenService<A::Service, B::Service, Req>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -249,8 +247,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
 
-    impl Service for Srv1 {
-        type Request = Result<&'static str, &'static str>;
+    impl Service<Result<&'static str, &'static str>> for Srv1 {
         type Response = &'static str;
         type Error = ();
         type Future = Ready<Result<Self::Response, Self::Error>>;
@@ -270,8 +267,7 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
-        type Request = Result<&'static str, ()>;
+    impl Service<Result<&'static str, ()>> for Srv2 {
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
diff --git a/actix-service/src/transform.rs b/actix-service/src/transform.rs
index 0ebfc5b7..7f0634e7 100644
--- a/actix-service/src/transform.rs
+++ b/actix-service/src/transform.rs
@@ -1,18 +1,18 @@
-use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::task::{Context, Poll};
+use std::{future::Future, marker::PhantomData};
 
 use crate::transform_err::TransformMapInitErr;
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
 /// Apply transform to a service.
-pub fn apply<T, S, U>(t: T, factory: U) -> ApplyTransform<T, S>
+pub fn apply<T, S, U, Req>(t: T, factory: U) -> ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
-    U: IntoServiceFactory<S>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
+    U: IntoServiceFactory<S, Req>,
 {
     ApplyTransform::new(t, factory.into_factory())
 }
@@ -89,10 +89,7 @@ where
 ///     }
 /// }
 /// ```
-pub trait Transform<S> {
-    /// Requests handled by the service.
-    type Request;
-
+pub trait Transform<S, Req> {
     /// Responses given by the service.
     type Response;
 
@@ -100,11 +97,7 @@ pub trait Transform<S> {
     type Error;
 
     /// The `TransformService` value created by this factory
-    type Transform: Service<
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
+    type Transform: Service<Req, Response = Self::Response, Error = Self::Error>;
 
     /// Errors produced while building a transform service.
     type InitError;
@@ -117,7 +110,7 @@ pub trait Transform<S> {
 
     /// Map this transform's factory error to a different error,
     /// returning a new transform service factory.
-    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E + Clone,
@@ -126,11 +119,10 @@ pub trait Transform<S> {
     }
 }
 
-impl<T, S> Transform<S> for Rc<T>
+impl<T, S, Req> Transform<S, Req> for Rc<T>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
@@ -142,11 +134,10 @@ where
     }
 }
 
-impl<T, S> Transform<S> for Arc<T>
+impl<T, S, Req> Transform<S, Req> for Arc<T>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
@@ -159,38 +150,37 @@ where
 }
 
 /// `Apply` transform to new service
-pub struct ApplyTransform<T, S>(Rc<(T, S)>);
+pub struct ApplyTransform<T, S, Req>(Rc<(T, S)>, PhantomData<Req>);
 
-impl<T, S> ApplyTransform<T, S>
+impl<T, S, Req> ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     /// Create new `ApplyTransform` new service instance
     fn new(t: T, service: S) -> Self {
-        Self(Rc::new((t, service)))
+        Self(Rc::new((t, service)), PhantomData)
     }
 }
 
-impl<T, S> Clone for ApplyTransform<T, S> {
+impl<T, S, Req> Clone for ApplyTransform<T, S, Req> {
     fn clone(&self) -> Self {
-        ApplyTransform(self.0.clone())
+        ApplyTransform(self.0.clone(), PhantomData)
     }
 }
 
-impl<T, S> ServiceFactory for ApplyTransform<T, S>
+impl<T, S, Req> ServiceFactory<Req> for ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
 
     type Config = S::Config;
     type Service = T::Transform;
     type InitError = T::InitError;
-    type Future = ApplyTransformFuture<T, S>;
+    type Future = ApplyTransformFuture<T, S, Req>;
 
     fn new_service(&self, cfg: S::Config) -> Self::Future {
         ApplyTransformFuture {
@@ -201,30 +191,30 @@ where
 }
 
 #[pin_project::pin_project]
-pub struct ApplyTransformFuture<T, S>
+pub struct ApplyTransformFuture<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     store: Rc<(T, S)>,
     #[pin]
-    state: ApplyTransformFutureState<T, S>,
+    state: ApplyTransformFutureState<T, S, Req>,
 }
 
 #[pin_project::pin_project(project = ApplyTransformFutureStateProj)]
-pub enum ApplyTransformFutureState<T, S>
+pub enum ApplyTransformFutureState<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     A(#[pin] S::Future),
     B(#[pin] T::Future),
 }
 
-impl<T, S> Future for ApplyTransformFuture<T, S>
+impl<T, S, Req> Future for ApplyTransformFuture<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     type Output = Result<T::Transform, T::InitError>;
 
diff --git a/actix-service/src/transform_err.rs b/actix-service/src/transform_err.rs
index 9d306f0c..1d1b9576 100644
--- a/actix-service/src/transform_err.rs
+++ b/actix-service/src/transform_err.rs
@@ -9,65 +9,64 @@ use super::Transform;
 /// transform's init error.
 ///
 /// This is created by the `Transform::map_init_err` method.
-pub struct TransformMapInitErr<T, S, F, E> {
-    t: T,
-    f: F,
-    e: PhantomData<(S, E)>,
+pub struct TransformMapInitErr<T, S, Req, F, E> {
+    transform: T,
+    mapper: F,
+    _phantom: PhantomData<(S, Req, E)>,
 }
 
-impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+impl<T, S, F, E, Req> TransformMapInitErr<T, S, Req, F, E> {
     pub(crate) fn new(t: T, f: F) -> Self
     where
-        T: Transform<S>,
+        T: Transform<S, Req>,
         F: Fn(T::InitError) -> E,
     {
         Self {
-            t,
-            f,
-            e: PhantomData,
+            transform: t,
+            mapper: f,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+impl<T, S, Req, F, E> Clone for TransformMapInitErr<T, S, Req, F, E>
 where
     T: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
-            t: self.t.clone(),
-            f: self.f.clone(),
-            e: PhantomData,
+            transform: self.transform.clone(),
+            mapper: self.mapper.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E>
+impl<T, S, F, E, Req> Transform<S, Req> for TransformMapInitErr<T, S, Req, F, E>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E + Clone,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type Transform = T::Transform;
 
     type InitError = E;
-    type Future = TransformMapInitErrFuture<T, S, F, E>;
+    type Future = TransformMapInitErrFuture<T, S, F, E, Req>;
 
     fn new_transform(&self, service: S) -> Self::Future {
         TransformMapInitErrFuture {
-            fut: self.t.new_transform(service),
-            f: self.f.clone(),
+            fut: self.transform.new_transform(service),
+            f: self.mapper.clone(),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct TransformMapInitErrFuture<T, S, F, E>
+pub struct TransformMapInitErrFuture<T, S, F, E, Req>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E,
 {
     #[pin]
@@ -75,9 +74,9 @@ where
     f: F,
 }
 
-impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E>
+impl<T, S, F, E, Req> Future for TransformMapInitErrFuture<T, S, F, E, Req>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E + Clone,
 {
     type Output = Result<T::Transform, E>;