diff --git a/CHANGES.md b/CHANGES.md
index c282cc031..b4502f3d5 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,10 @@
 # Changes
 
+## [0.3.0] - xxx
+
+* Use new `Service<Request>` trait
+
+
 ## [0.2.4] - 2018-11-21
 
 ### Added
diff --git a/Cargo.toml b/Cargo.toml
index 5e00dca5e..f36384081 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-net"
-version = "0.2.4"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix net - framework for the compisible network services for Rust (experimental)"
 readme = "README.md"
@@ -57,7 +57,7 @@ tokio-tcp = "0.1"
 tokio-timer = "0.2"
 tokio-reactor = "0.1"
 tokio-current-thread = "0.1"
-tower-service = "0.1"
+tower-service = { path="../../actix/tower/tower-service/" }
 trust-dns-proto = "^0.5.0"
 trust-dns-resolver = "^0.10.0"
 
diff --git a/src/cloneable.rs b/src/cloneable.rs
index ec3fd0b44..1e388ec10 100644
--- a/src/cloneable.rs
+++ b/src/cloneable.rs
@@ -1,31 +1,35 @@
+use std::marker::PhantomData;
+
 use futures::Poll;
 
 use super::cell::Cell;
 use super::service::Service;
 
 /// Service that allows to turn non-clone service to a service with `Clone` impl
-pub struct CloneableService<S: Service + 'static> {
+pub struct CloneableService<S: Service<R> + 'static, R> {
     service: Cell<S>,
+    _t: PhantomData<R>,
 }
 
-impl<S: Service + 'static> CloneableService<S> {
+impl<S: Service<R> + 'static, R> CloneableService<S, R> {
     pub fn new(service: S) -> Self {
         Self {
             service: Cell::new(service),
+            _t: PhantomData,
         }
     }
 }
 
-impl<S: Service + 'static> Clone for CloneableService<S> {
+impl<S: Service<R> + 'static, R> Clone for CloneableService<S, R> {
     fn clone(&self) -> Self {
         Self {
             service: self.service.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<S: Service + 'static> Service for CloneableService<S> {
-    type Request = S::Request;
+impl<S: Service<R> + 'static, R> Service<R> for CloneableService<S, R> {
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -34,7 +38,7 @@ impl<S: Service + 'static> Service for CloneableService<S> {
         self.service.borrow_mut().poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         self.service.borrow_mut().call(req)
     }
 }
diff --git a/src/connector.rs b/src/connector.rs
index e244f3e46..d82f5dbc1 100644
--- a/src/connector.rs
+++ b/src/connector.rs
@@ -168,23 +168,24 @@ impl Connector {
     /// Create new connector with custom resolver
     pub fn with_resolver(
         resolver: Resolver<Connect>,
-    ) -> impl Service<Request = Connect, Response = (Connect, TcpStream), Error = ConnectorError>
-                 + Clone {
+    ) -> impl Service<Connect, Response = (Connect, TcpStream), Error = ConnectorError> + Clone
+    {
         Connector { resolver }
     }
 
-    /// Create new default connector service
-    pub fn new_service_with_config<E>(
-        cfg: ResolverConfig,
-        opts: ResolverOpts,
-    ) -> impl NewService<
-        Request = Connect,
-        Response = (Connect, TcpStream),
-        Error = ConnectorError,
-        InitError = E,
-    > + Clone {
-        move || -> FutureResult<Connector, E> { ok(Connector::new(cfg.clone(), opts)) }
-    }
+    // /// Create new default connector service
+    // pub fn new_service_with_config<E>(
+    //     cfg: ResolverConfig,
+    //     opts: ResolverOpts,
+    // ) -> impl NewService<
+    //     Connect,
+    //     Response = (Connect, TcpStream),
+    //     Error = ConnectorError,
+    //     InitError = E,
+    //     Service = impl Service<Connect, Response = (Connect, TcpStream), Error = ConnectorError> + Clone,
+    // > + Clone {
+    //     move || -> FutureResult<Connector, E> { ok(Connector::new(cfg.clone(), opts)) }
+    // }
 }
 
 impl Clone for Connector {
@@ -195,8 +196,7 @@ impl Clone for Connector {
     }
 }
 
-impl Service for Connector {
-    type Request = Connect;
+impl Service<Connect> for Connector {
     type Response = (Connect, TcpStream);
     type Error = ConnectorError;
     type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
@@ -205,7 +205,7 @@ impl Service for Connector {
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Connect) -> Self::Future {
         match req.kind {
             ConnectKind::Host { host: _, port: _ } => Either::A(ConnectorFuture {
                 fut: self.resolver.call(req),
@@ -273,8 +273,7 @@ impl<T: RequestPort> Default for TcpConnector<T> {
     }
 }
 
-impl<T: RequestPort> Service for TcpConnector<T> {
-    type Request = (T, VecDeque<IpAddr>);
+impl<T: RequestPort> Service<(T, VecDeque<IpAddr>)> for TcpConnector<T> {
     type Response = (T, TcpStream);
     type Error = io::Error;
     type Future = TcpConnectorResponse<T>;
@@ -283,7 +282,7 @@ impl<T: RequestPort> Service for TcpConnector<T> {
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, (req, addrs): Self::Request) -> Self::Future {
+    fn call(&mut self, (req, addrs): (T, VecDeque<IpAddr>)) -> Self::Future {
         TcpConnectorResponse::new(req, addrs)
     }
 }
@@ -354,8 +353,7 @@ impl DefaultConnector {
     }
 }
 
-impl Service for DefaultConnector {
-    type Request = Connect;
+impl Service<Connect> for DefaultConnector {
     type Response = TcpStream;
     type Error = ConnectorError;
     type Future = DefaultConnectorFuture;
@@ -364,7 +362,7 @@ impl Service for DefaultConnector {
         self.0.poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Connect) -> Self::Future {
         DefaultConnectorFuture {
             fut: self.0.call(req),
         }
diff --git a/src/either.rs b/src/either.rs
index efc6b3d52..677ccf450 100644
--- a/src/either.rs
+++ b/src/either.rs
@@ -13,12 +13,11 @@ pub enum EitherService<A, B> {
     B(B),
 }
 
-impl<A, B> Service for EitherService<A, B>
+impl<A, B, Request> Service<Request> for EitherService<A, B>
 where
-    A: Service,
-    B: Service<Request = A::Request, Response = A::Response, Error = A::Error>,
+    A: Service<Request>,
+    B: Service<Request, Response = A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type Future = future::Either<A::Future, B::Future>;
@@ -30,7 +29,7 @@ where
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         match self {
             EitherService::A(ref mut inner) => future::Either::A(inner.call(req)),
             EitherService::B(ref mut inner) => future::Either::B(inner.call(req)),
@@ -44,22 +43,16 @@ pub enum Either<A, B> {
     B(B),
 }
 
-impl<A, B> NewService for Either<A, B>
+impl<A, B, Request> NewService<Request> for Either<A, B>
 where
-    A: NewService,
-    B: NewService<
-        Request = A::Request,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
+    A: NewService<Request>,
+    B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type InitError = A::InitError;
     type Service = EitherService<A::Service, B::Service>;
-    type Future = EitherNewService<A, B>;
+    type Future = EitherNewService<A, B, Request>;
 
     fn new_service(&self) -> Self::Future {
         match self {
@@ -70,20 +63,15 @@ where
 }
 
 #[doc(hidden)]
-pub enum EitherNewService<A: NewService, B: NewService> {
+pub enum EitherNewService<A: NewService<R>, B: NewService<R>, R> {
     A(A::Future),
     B(B::Future),
 }
 
-impl<A, B> Future for EitherNewService<A, B>
+impl<A, B, Request> Future for EitherNewService<A, B, Request>
 where
-    A: NewService,
-    B: NewService<
-        Request = A::Request,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
+    A: NewService<Request>,
+    B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
 {
     type Item = EitherService<A::Service, B::Service>;
     type Error = A::InitError;
diff --git a/src/framed.rs b/src/framed.rs
index 69cd6bd68..9ea8f71fd 100644
--- a/src/framed.rs
+++ b/src/framed.rs
@@ -24,13 +24,13 @@ impl<S, T, U> FramedNewService<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>> + Clone,
-    <<S as NewService>::Service as Service>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    S: NewService<Request<U>, Response = Response<U>>,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
-    pub fn new<F1: IntoNewService<S>>(factory: F1) -> Self {
+    pub fn new<F1: IntoNewService<S, Request<U>>>(factory: F1) -> Self {
         Self {
             factory: factory.into_new_service(),
             _t: PhantomData,
@@ -50,17 +50,16 @@ where
     }
 }
 
-impl<S, T, U> NewService for FramedNewService<S, T, U>
+impl<S, T, U> NewService<Framed<T, U>> for FramedNewService<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>> + Clone,
-    <<S as NewService>::Service as Service>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    S: NewService<Request<U>, Response = Response<U>> + Clone,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
-    type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
     type InitError = S::InitError;
@@ -92,17 +91,16 @@ where
     }
 }
 
-impl<S, T, U> Service for FramedService<S, T, U>
+impl<S, T, U> Service<Framed<T, U>> for FramedService<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    S: NewService<Request<U>, Response = Response<U>>,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
-    type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
     type Future = FramedServiceResponseFuture<S, T, U>;
@@ -111,7 +109,7 @@ where
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Framed<T, U>) -> Self::Future {
         FramedServiceResponseFuture {
             fut: self.factory.new_service(),
 
@@ -125,9 +123,9 @@ pub struct FramedServiceResponseFuture<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    S: NewService<Request<U>, Response = Response<U>>,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
@@ -139,9 +137,9 @@ impl<S, T, U> Future for FramedServiceResponseFuture<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    S: NewService<Request<U>, Response = Response<U>>,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
@@ -176,7 +174,7 @@ impl<E, U: Encoder + Decoder> From<E> for FramedTransportError<E, U> {
 /// and pass then to the service.
 pub struct FramedTransport<S, T, U>
 where
-    S: Service,
+    S: Service<Request<U>, Response = Response<U>>,
     T: AsyncRead + AsyncWrite,
     U: Encoder + Decoder,
 {
@@ -190,7 +188,7 @@ where
     flushed: bool,
 }
 
-enum TransportState<S: Service, U: Encoder + Decoder> {
+enum TransportState<S: Service<Request<U>>, U: Encoder + Decoder> {
     Processing,
     Error(FramedTransportError<S::Error, U>),
     EncoderError(FramedTransportError<S::Error, U>),
@@ -201,12 +199,12 @@ impl<S, T, U> FramedTransport<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Future: 'static,
     S::Error: 'static,
     <U as Encoder>::Error: 'static,
 {
-    pub fn new<F: IntoService<S>>(framed: Framed<T, U>, service: F) -> Self {
+    pub fn new<F: IntoService<S, Request<U>>>(framed: Framed<T, U>, service: F) -> Self {
         let (write_tx, write_rx) = mpsc::channel(16);
         FramedTransport {
             framed,
@@ -248,7 +246,7 @@ impl<S, T, U> FramedTransport<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Future: 'static,
     S::Error: 'static,
     <U as Encoder>::Item: 'static,
@@ -377,7 +375,7 @@ impl<S, T, U> Future for FramedTransport<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Future: 'static,
     S::Error: 'static,
     <U as Encoder>::Item: 'static,
@@ -437,13 +435,12 @@ where
     }
 }
 
-impl<T, U, F> NewService for IntoFramed<T, U, F>
+impl<T, U, F> NewService<T> for IntoFramed<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
     U: Encoder + Decoder,
 {
-    type Request = T;
     type Response = Framed<T, U>;
     type Error = ();
     type InitError = ();
@@ -468,13 +465,12 @@ where
     _t: PhantomData<(T,)>,
 }
 
-impl<T, U, F> Service for IntoFramedService<T, U, F>
+impl<T, U, F> Service<T> for IntoFramedService<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
     U: Encoder + Decoder,
 {
-    type Request = T;
     type Response = Framed<T, U>;
     type Error = ();
     type Future = FutureResult<Self::Response, Self::Error>;
@@ -483,7 +479,7 @@ where
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         ok(Framed::new(req, (self.factory)()))
     }
 }
diff --git a/src/inflight.rs b/src/inflight.rs
index 6ee82a8c1..acda9dfb5 100644
--- a/src/inflight.rs
+++ b/src/inflight.rs
@@ -12,11 +12,12 @@ pub struct InFlight<T> {
     max_inflight: usize,
 }
 
-impl<T> InFlight<T>
-where
-    T: NewService,
-{
-    pub fn new<F: IntoNewService<T>>(factory: F) -> Self {
+impl<T> InFlight<T> {
+    pub fn new<F, Request>(factory: F) -> Self
+    where
+        T: NewService<Request>,
+        F: IntoNewService<T, Request>,
+    {
         Self {
             factory: factory.into_new_service(),
             max_inflight: 15,
@@ -32,16 +33,15 @@ where
     }
 }
 
-impl<T> NewService for InFlight<T>
+impl<T, Request> NewService<Request> for InFlight<T>
 where
-    T: NewService,
+    T: NewService<Request>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
     type Service = InFlightService<T::Service>;
-    type Future = InFlightResponseFuture<T>;
+    type Future = InFlightResponseFuture<T, Request>;
 
     fn new_service(&self) -> Self::Future {
         InFlightResponseFuture {
@@ -51,12 +51,12 @@ where
     }
 }
 
-pub struct InFlightResponseFuture<T: NewService> {
+pub struct InFlightResponseFuture<T: NewService<Request>, Request> {
     fut: T::Future,
     max_inflight: usize,
 }
 
-impl<T: NewService> Future for InFlightResponseFuture<T> {
+impl<T: NewService<Request>, Request> Future for InFlightResponseFuture<T, Request> {
     type Item = InFlightService<T::Service>;
     type Error = T::InitError;
 
@@ -73,15 +73,23 @@ pub struct InFlightService<T> {
     count: Counter,
 }
 
-impl<T: Service> InFlightService<T> {
-    pub fn new<F: IntoService<T>>(service: F) -> Self {
+impl<T> InFlightService<T> {
+    pub fn new<F, Request>(service: F) -> Self
+    where
+        T: Service<Request>,
+        F: IntoService<T, Request>,
+    {
         Self {
             service: service.into_service(),
             count: Counter::new(15),
         }
     }
 
-    pub fn with_max_inflight<F: IntoService<T>>(max: usize, service: F) -> Self {
+    pub fn with_max_inflight<F, Request>(max: usize, service: F) -> Self
+    where
+        T: Service<Request>,
+        F: IntoService<T, Request>,
+    {
         Self {
             service: service.into_service(),
             count: Counter::new(max),
@@ -89,11 +97,13 @@ impl<T: Service> InFlightService<T> {
     }
 }
 
-impl<T: Service> Service for InFlightService<T> {
-    type Request = T::Request;
+impl<T, Request> Service<Request> for InFlightService<T>
+where
+    T: Service<Request>,
+{
     type Response = T::Response;
     type Error = T::Error;
-    type Future = InFlightServiceResponse<T>;
+    type Future = InFlightServiceResponse<T, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         let res = self.service.poll_ready();
@@ -103,22 +113,21 @@ impl<T: Service> Service for InFlightService<T> {
         res
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         InFlightServiceResponse {
             fut: self.service.call(req),
-            guard: self.count.get(),
+            _guard: self.count.get(),
         }
     }
 }
 
 #[doc(hidden)]
-pub struct InFlightServiceResponse<T: Service> {
+pub struct InFlightServiceResponse<T: Service<Request>, Request> {
     fut: T::Future,
-    #[allow(dead_code)]
-    guard: CounterGuard,
+    _guard: CounterGuard,
 }
 
-impl<T: Service> Future for InFlightServiceResponse<T> {
+impl<T: Service<Request>, Request> Future for InFlightServiceResponse<T, Request> {
     type Item = T::Response;
     type Error = T::Error;
 
diff --git a/src/keepalive.rs b/src/keepalive.rs
index 5ee0892d4..d3e31f330 100644
--- a/src/keepalive.rs
+++ b/src/keepalive.rs
@@ -32,7 +32,7 @@ where
 
 impl<R, E, F> Clone for KeepAlive<R, E, F>
 where
-    F: Fn() -> E + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         KeepAlive {
@@ -44,11 +44,10 @@ where
     }
 }
 
-impl<R, E, F> NewService for KeepAlive<R, E, F>
+impl<R, E, F> NewService<R> for KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
 {
-    type Request = R;
     type Response = R;
     type Error = E;
     type InitError = Never;
@@ -90,11 +89,10 @@ where
     }
 }
 
-impl<R, E, F> Service for KeepAliveService<R, E, F>
+impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
-    type Request = R;
     type Response = R;
     type Error = E;
     type Future = FutureResult<R, E>;
@@ -116,7 +114,7 @@ where
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         self.expire = self.time.now() + self.ka;
         ok(req)
     }
diff --git a/src/resolver.rs b/src/resolver.rs
index 28196fee0..0c87c78fe 100644
--- a/src/resolver.rs
+++ b/src/resolver.rs
@@ -70,8 +70,7 @@ impl<T> Clone for Resolver<T> {
     }
 }
 
-impl<T: RequestHost> Service for Resolver<T> {
-    type Request = T;
+impl<T: RequestHost> Service<T> for Resolver<T> {
     type Response = (T, VecDeque<IpAddr>);
     type Error = ResolveError;
     type Future = ResolverFuture<T>;
@@ -80,7 +79,7 @@ impl<T: RequestHost> Service for Resolver<T> {
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         ResolverFuture::new(req, &self.resolver)
     }
 }
diff --git a/src/server/config.rs b/src/server/config.rs
index 6fba8f92a..d959c3028 100644
--- a/src/server/config.rs
+++ b/src/server/config.rs
@@ -154,8 +154,8 @@ impl ServiceRuntime {
 
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
-        F: IntoNewService<T>,
-        T: NewService<Request = TcpStream, Response = ()> + 'static,
+        F: IntoNewService<T, TcpStream>,
+        T: NewService<TcpStream, Response = ()> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -176,7 +176,7 @@ impl ServiceRuntime {
 
 type BoxedNewService = Box<
     NewService<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         InitError = (),
@@ -189,15 +189,14 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> NewService for ServiceFactory<T>
+impl<T> NewService<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
 where
-    T: NewService<Request = TcpStream, Response = ()>,
+    T: NewService<TcpStream, Response = ()>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
     T::InitError: fmt::Debug + 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type InitError = ();
diff --git a/src/server/services.rs b/src/server/services.rs
index 58be7f737..151b62006 100644
--- a/src/server/services.rs
+++ b/src/server/services.rs
@@ -22,13 +22,13 @@ pub enum ServerMessage {
 }
 
 pub trait StreamServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = TcpStream, Response = ()>;
+    type NewService: NewService<TcpStream, Response = ()>;
 
     fn create(&self) -> Self::NewService;
 }
 
 pub trait ServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = ServerMessage, Response = ()>;
+    type NewService: NewService<ServerMessage, Response = ()>;
 
     fn create(&self) -> Self::NewService;
 }
@@ -43,7 +43,7 @@ pub(crate) trait InternalServiceFactory: Send {
 
 pub(crate) type BoxedServerService = Box<
     Service<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         Future = FutureResult<(), ()>,
@@ -60,13 +60,12 @@ impl<T> StreamService<T> {
     }
 }
 
-impl<T> Service for StreamService<T>
+impl<T> Service<(Option<CounterGuard>, ServerMessage)> for StreamService<T>
 where
-    T: Service<Request = TcpStream, Response = ()>,
+    T: Service<TcpStream, Response = ()>,
     T::Future: 'static,
     T::Error: 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = FutureResult<(), ()>;
@@ -107,13 +106,12 @@ impl<T> ServerService<T> {
     }
 }
 
-impl<T> Service for ServerService<T>
+impl<T> Service<(Option<CounterGuard>, ServerMessage)> for ServerService<T>
 where
-    T: Service<Request = ServerMessage, Response = ()>,
+    T: Service<ServerMessage, Response = ()>,
     T::Future: 'static,
     T::Error: 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = FutureResult<(), ()>;
@@ -240,7 +238,7 @@ impl InternalServiceFactory for Box<InternalServiceFactory> {
 impl<F, T> ServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = ServerMessage, Response = ()>,
+    T: NewService<ServerMessage, Response = ()>,
 {
     type NewService = T;
 
@@ -252,7 +250,7 @@ where
 impl<F, T> StreamServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = TcpStream, Response = ()>,
+    T: NewService<TcpStream, Response = ()>,
 {
     type NewService = T;
 
diff --git a/src/service/and_then.rs b/src/service/and_then.rs
index 9dd672770..953ba8dbb 100644
--- a/src/service/and_then.rs
+++ b/src/service/and_then.rs
@@ -12,21 +12,21 @@ pub struct AndThen<A, B> {
     b: Cell<B>,
 }
 
-impl<A, B> AndThen<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
+impl<A, B> AndThen<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new(a: A, b: B) -> Self {
+    pub fn new<Request>(a: A, b: B) -> Self
+    where
+        A: Service<Request>,
+        B: Service<A::Response, Error = A::Error>,
+    {
         Self { a, b: Cell::new(b) }
     }
 }
 
 impl<A, B> Clone for AndThen<A, B>
 where
-    A: Service + Clone,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Clone,
+    B: Clone,
 {
     fn clone(&self) -> Self {
         AndThen {
@@ -36,40 +36,39 @@ where
     }
 }
 
-impl<A, B> Service for AndThen<A, B>
+impl<A, B, Request> Service<Request> for AndThen<A, B>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Request>,
+    B: Service<A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B>;
+    type Future = AndThenFuture<A, B, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         let _ = try_ready!(self.a.poll_ready());
         self.b.borrow_mut().poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         AndThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct AndThenFuture<A, B>
+pub struct AndThenFuture<A, B, Request>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Request>,
+    B: Service<A::Response, Error = A::Error>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
     fut_a: A::Future,
 }
 
-impl<A, B> AndThenFuture<A, B>
+impl<A, B, Request> AndThenFuture<A, B, Request>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Request>,
+    B: Service<A::Response, Error = A::Error>,
 {
     fn new(fut_a: A::Future, b: Cell<B>) -> Self {
         AndThenFuture {
@@ -80,10 +79,10 @@ where
     }
 }
 
-impl<A, B> Future for AndThenFuture<A, B>
+impl<A, B, Request> Future for AndThenFuture<A, B, Request>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Request>,
+    B: Service<A::Response, Error = A::Error>,
     B::Error: Into<A::Error>,
 {
     type Item = B::Response;
@@ -111,13 +110,13 @@ pub struct AndThenNewService<A, B> {
     b: B,
 }
 
-impl<A, B> AndThenNewService<A, B>
-where
-    A: NewService,
-    B: NewService,
-{
+impl<A, B> AndThenNewService<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self {
+    pub fn new<Request, F: IntoNewService<B, A::Response>>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    {
         Self {
             a,
             b: f.into_new_service(),
@@ -125,18 +124,17 @@ where
     }
 }
 
-impl<A, B> NewService for AndThenNewService<A, B>
+impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
 where
-    A: NewService,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService<Request>,
+    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
     type Service = AndThen<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B>;
+    type Future = AndThenNewServiceFuture<A, B, Request>;
 
     fn new_service(&self) -> Self::Future {
         AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@@ -145,8 +143,8 @@ where
 
 impl<A, B> Clone for AndThenNewService<A, B>
 where
-    A: NewService + Clone,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError> + Clone,
+    A: Clone,
+    B: Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -156,10 +154,10 @@ where
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B>
+pub struct AndThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
-    B: NewService,
+    A: NewService<Request>,
+    B: NewService<A::Response>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -167,10 +165,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> AndThenNewServiceFuture<A, B>
+impl<A, B, Request> AndThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
-    B: NewService,
+    A: NewService<Request>,
+    B: NewService<A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenNewServiceFuture {
@@ -182,10 +180,10 @@ where
     }
 }
 
-impl<A, B> Future for AndThenNewServiceFuture<A, B>
+impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService<Request>,
+    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
 {
     type Item = AndThen<A::Service, B::Service>;
     type Error = A::InitError;
diff --git a/src/service/apply.rs b/src/service/apply.rs
index 9161775c6..f4d559ae5 100644
--- a/src/service/apply.rs
+++ b/src/service/apply.rs
@@ -5,21 +5,23 @@ use futures::{Async, Future, IntoFuture, Poll};
 use super::{IntoNewService, IntoService, NewService, Service};
 
 /// `Apply` service combinator
-pub struct Apply<T, F, R, Req> {
+pub struct Apply<T, F, In, Out, Request>
+where
+    T: Service<Request>,
+{
     service: T,
     f: F,
-    r: PhantomData<(Req, R)>,
+    r: PhantomData<(In, Out, Request)>,
 }
 
-impl<T, F, R, Req> Apply<T, F, R, Req>
+impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
 where
-    T: Service,
-    T::Error: Into<<R::Future as Future>::Error>,
-    F: Fn(Req, &mut T) -> R,
-    R: IntoFuture,
+    T: Service<Request>,
+    F: Fn(In, &mut T) -> Out,
+    Out: IntoFuture,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T>>(service: I, f: F) -> Self {
+    pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
         Self {
             service: service.into_service(),
             f,
@@ -28,12 +30,10 @@ where
     }
 }
 
-impl<T, F, R, Req> Clone for Apply<T, F, R, Req>
+impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
 where
-    T: Service + Clone,
-    T::Error: Into<<R::Future as Future>::Error>,
-    F: Fn(Req, &mut T) -> R + Clone,
-    R: IntoFuture,
+    T: Service<Request> + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Apply {
@@ -44,42 +44,43 @@ where
     }
 }
 
-impl<T, F, R, Req> Service for Apply<T, F, R, Req>
+impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
 where
-    T: Service,
-    T::Error: Into<<R::Future as Future>::Error>,
-    F: Fn(Req, &mut T) -> R,
-    R: IntoFuture,
+    T: Service<Request, Error = Out::Error>,
+    F: Fn(In, &mut T) -> Out,
+    Out: IntoFuture,
 {
-    type Request = Req;
-    type Response = <R::Future as Future>::Item;
-    type Error = <R::Future as Future>::Error;
-    type Future = R::Future;
+    type Response = <Out::Future as Future>::Item;
+    type Error = <Out::Future as Future>::Error;
+    type Future = Out::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(|e| e.into())
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: In) -> Self::Future {
         (self.f)(req, &mut self.service).into_future()
     }
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, R, Req> {
+pub struct ApplyNewService<T, F, In, Out, Request>
+where
+    T: NewService<Request>,
+{
     service: T,
     f: F,
-    r: PhantomData<Fn(Req) -> R>,
+    r: PhantomData<(In, Out, Request)>,
 }
 
-impl<T, F, R, Req> ApplyNewService<T, F, R, Req>
+impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
 where
-    T: NewService,
-    F: Fn(Req, &mut T::Service) -> R,
-    R: IntoFuture,
+    T: NewService<Request>,
+    F: Fn(In, &mut T::Service) -> Out,
+    Out: IntoFuture,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
+    pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
         Self {
             f,
             service: service.into_new_service(),
@@ -88,11 +89,11 @@ where
     }
 }
 
-impl<T, F, R, Req> Clone for ApplyNewService<T, F, R, Req>
+impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
 where
-    T: NewService + Clone,
-    F: Fn(Req, &mut T::Service) -> R + Clone,
-    R: IntoFuture,
+    T: NewService<Request> + Clone,
+    F: Fn(Out, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
         Self {
@@ -103,42 +104,40 @@ where
     }
 }
 
-impl<T, F, R, Req> NewService for ApplyNewService<T, F, R, Req>
+impl<T, F, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
 where
-    T: NewService,
-    T::Error: Into<<R::Future as Future>::Error>,
-    F: Fn(Req, &mut T::Service) -> R + Clone,
-    R: IntoFuture,
+    T: NewService<Request, Error = Out::Error>,
+    F: Fn(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
 {
-    type Request = Req;
-    type Response = <R::Future as Future>::Item;
-    type Error = <R::Future as Future>::Error;
-    type Service = Apply<T::Service, F, R, Req>;
+    type Response = <Out::Future as Future>::Item;
+    type Error = <Out::Future as Future>::Error;
+    type Service = Apply<T::Service, F, In, Out, Request>;
 
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, R, Req>;
+    type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
 
     fn new_service(&self) -> Self::Future {
         ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, R, Req>
+pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
 where
-    T: NewService,
-    F: Fn(Req, &mut T::Service) -> R,
-    R: IntoFuture,
+    T: NewService<Request>,
+    F: Fn(In, &mut T::Service) -> Out,
+    Out: IntoFuture,
 {
     fut: T::Future,
     f: Option<F>,
-    r: PhantomData<Fn(Req) -> R>,
+    r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, R, Req> ApplyNewServiceFuture<T, F, R, Req>
+impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
 where
-    T: NewService,
-    F: Fn(Req, &mut T::Service) -> R,
-    R: IntoFuture,
+    T: NewService<Request>,
+    F: Fn(In, &mut T::Service) -> Out,
+    Out: IntoFuture,
 {
     fn new(fut: T::Future, f: F) -> Self {
         ApplyNewServiceFuture {
@@ -149,14 +148,13 @@ where
     }
 }
 
-impl<T, F, R, Req> Future for ApplyNewServiceFuture<T, F, R, Req>
+impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
 where
-    T: NewService,
-    T::Error: Into<<R::Future as Future>::Error>,
-    F: Fn(Req, &mut T::Service) -> R,
-    R: IntoFuture,
+    T: NewService<Request>,
+    F: Fn(In, &mut T::Service) -> Out,
+    Out: IntoFuture,
 {
-    type Item = Apply<T::Service, F, R, Req>;
+    type Item = Apply<T::Service, F, In, Out, Request>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
diff --git a/src/service/fn_service.rs b/src/service/fn_service.rs
index e81ca6429..d6e19e8a4 100644
--- a/src/service/fn_service.rs
+++ b/src/service/fn_service.rs
@@ -42,12 +42,11 @@ where
     }
 }
 
-impl<F, Req, Resp, E, Fut> Service for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>
 where
     F: Fn(Req) -> Fut,
     Fut: IntoFuture<Item = Resp, Error = E>,
 {
-    type Request = Req;
     type Response = Resp;
     type Error = E;
     type Future = Fut::Future;
@@ -61,7 +60,7 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F
+impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>, Req> for F
 where
     F: Fn(Req) -> Fut + 'static,
     Fut: IntoFuture<Item = Resp, Error = Err>,
@@ -93,12 +92,11 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> NewService for FnNewService<F, Req, Resp, Err, Fut>
+impl<F, Req, Resp, Err, Fut> NewService<Req> for FnNewService<F, Req, Resp, Err, Fut>
 where
     F: Fn(Req) -> Fut + Clone,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
-    type Request = Req;
     type Response = Resp;
     type Error = Err;
     type Service = FnService<F, Req, Resp, Err, Fut>;
@@ -110,7 +108,7 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>> for F
+impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>, Req> for F
 where
     F: Fn(Req) -> Fut + Clone + 'static,
     Fut: IntoFuture<Item = Resp, Error = Err>,
diff --git a/src/service/from_err.rs b/src/service/from_err.rs
index 3c6961a0f..a82d662e2 100644
--- a/src/service/from_err.rs
+++ b/src/service/from_err.rs
@@ -7,16 +7,17 @@ use super::{NewService, Service};
 /// Service for the `from_err` combinator, changing the error type of a service.
 ///
 /// This is created by the `ServiceExt::from_err` method.
-pub struct FromErr<A, E>
-where
-    A: Service,
-{
+pub struct FromErr<A, E> {
     service: A,
     f: PhantomData<E>,
 }
 
-impl<A: Service, E: From<A::Error>> FromErr<A, E> {
-    pub(crate) fn new(service: A) -> Self {
+impl<A, E> FromErr<A, E> {
+    pub(crate) fn new<Request>(service: A) -> Self
+    where
+        A: Service<Request>,
+        E: From<A::Error>,
+    {
         FromErr {
             service,
             f: PhantomData,
@@ -26,8 +27,7 @@ impl<A: Service, E: From<A::Error>> FromErr<A, E> {
 
 impl<A, E> Clone for FromErr<A, E>
 where
-    A: Service + Clone,
-    E: From<A::Error>,
+    A: Clone,
 {
     fn clone(&self) -> Self {
         FromErr {
@@ -37,21 +37,20 @@ where
     }
 }
 
-impl<A, E> Service for FromErr<A, E>
+impl<A, E, Request> Service<Request> for FromErr<A, E>
 where
-    A: Service,
+    A: Service<Request>,
     E: From<A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = FromErrFuture<A, E>;
+    type Future = FromErrFuture<A, E, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), E> {
         Ok(self.service.poll_ready().map_err(E::from)?)
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         FromErrFuture {
             fut: self.service.call(req),
             f: PhantomData,
@@ -59,14 +58,14 @@ where
     }
 }
 
-pub struct FromErrFuture<A: Service, E> {
+pub struct FromErrFuture<A: Service<Request>, E, Request> {
     fut: A::Future,
     f: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrFuture<A, E>
+impl<A, E, Request> Future for FromErrFuture<A, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     E: From<A::Error>,
 {
     type Item = A::Response;
@@ -86,21 +85,20 @@ pub struct FromErrNewService<A, E> {
     e: PhantomData<E>,
 }
 
-impl<A, E> FromErrNewService<A, E>
-where
-    A: NewService,
-    E: From<A::Error>,
-{
+impl<A, E> FromErrNewService<A, E> {
     /// Create new `FromErr` new service instance
-    pub fn new(a: A) -> Self {
+    pub fn new<Request>(a: A) -> Self
+    where
+        A: NewService<Request>,
+        E: From<A::Error>,
+    {
         Self { a, e: PhantomData }
     }
 }
 
 impl<A, E> Clone for FromErrNewService<A, E>
 where
-    A: NewService + Clone,
-    E: From<A::Error>,
+    A: Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -110,18 +108,17 @@ where
     }
 }
 
-impl<A, E> NewService for FromErrNewService<A, E>
+impl<A, E, Request> NewService<Request> for FromErrNewService<A, E>
 where
-    A: NewService,
+    A: NewService<Request>,
     E: From<A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
     type Service = FromErr<A::Service, E>;
 
     type InitError = A::InitError;
-    type Future = FromErrNewServiceFuture<A, E>;
+    type Future = FromErrNewServiceFuture<A, E, Request>;
 
     fn new_service(&self) -> Self::Future {
         FromErrNewServiceFuture {
@@ -131,18 +128,18 @@ where
     }
 }
 
-pub struct FromErrNewServiceFuture<A, E>
+pub struct FromErrNewServiceFuture<A, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     E: From<A::Error>,
 {
     fut: A::Future,
     e: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrNewServiceFuture<A, E>
+impl<A, E, Request> Future for FromErrNewServiceFuture<A, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     E: From<A::Error>,
 {
     type Item = FromErr<A::Service, E>;
diff --git a/src/service/map.rs b/src/service/map.rs
index e44a1d2d9..7095e9c07 100644
--- a/src/service/map.rs
+++ b/src/service/map.rs
@@ -1,4 +1,4 @@
-use std::marker;
+use std::marker::PhantomData;
 
 use futures::{Async, Future, Poll};
 
@@ -7,83 +7,84 @@ use super::{NewService, Service};
 /// 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, R>
-where
-    A: Service,
-    F: Fn(A::Response) -> R,
-{
+pub struct Map<A, F, Response> {
     service: A,
     f: F,
+    _t: PhantomData<Response>,
 }
 
-impl<A, F, R> Map<A, F, R>
-where
-    A: Service,
-    F: Fn(A::Response) -> R,
-{
+impl<A, F, Response> Map<A, F, Response> {
     /// Create new `Map` combinator
-    pub fn new(service: A, f: F) -> Self {
-        Self { service, f }
+    pub fn new<Request>(service: A, f: F) -> Self
+    where
+        A: Service<Request>,
+        F: Fn(A::Response) -> Response,
+    {
+        Self {
+            service,
+            f,
+            _t: PhantomData,
+        }
     }
 }
 
-impl<A, F, R> Clone for Map<A, F, R>
+impl<A, F, Response> Clone for Map<A, F, Response>
 where
-    A: Service + Clone,
-    F: Fn(A::Response) -> R + Clone,
+    A: Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Map {
             service: self.service.clone(),
             f: self.f.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, F, R> Service for Map<A, F, R>
+impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>
 where
-    A: Service,
-    F: Fn(A::Response) -> R + Clone,
+    A: Service<Request>,
+    F: Fn(A::Response) -> Response + Clone,
 {
-    type Request = A::Request;
-    type Response = R;
+    type Response = Response;
     type Error = A::Error;
-    type Future = MapFuture<A, F, R>;
+    type Future = MapFuture<A, F, Request, Response>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapFuture<A, F, R>
+pub struct MapFuture<A, F, Request, Response>
 where
-    A: Service,
-    F: Fn(A::Response) -> R,
+    A: Service<Request>,
+    F: Fn(A::Response) -> Response,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, R> MapFuture<A, F, R>
+impl<A, F, Request, Response> MapFuture<A, F, Request, Response>
 where
-    A: Service,
-    F: Fn(A::Response) -> R,
+    A: Service<Request>,
+    F: Fn(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, R> Future for MapFuture<A, F, R>
+impl<A, F, Request, Response> Future for MapFuture<A, F, Request, Response>
 where
-    A: Service,
-    F: Fn(A::Response) -> R,
+    A: Service<Request>,
+    F: Fn(A::Response) -> Response,
 {
-    type Item = R;
+    type Item = Response;
     type Error = A::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -95,84 +96,83 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapNewService<A, F, R> {
+pub struct MapNewService<A, F, Response> {
     a: A,
     f: F,
-    r: marker::PhantomData<R>,
+    r: PhantomData<Response>,
 }
 
-impl<A, F, R> MapNewService<A, F, R>
-where
-    A: NewService,
-    F: Fn(A::Response) -> R,
-{
+impl<A, F, Response> MapNewService<A, F, Response> {
     /// Create new `Map` new service instance
-    pub fn new(a: A, f: F) -> Self {
+    pub fn new<Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        F: Fn(A::Response) -> Response,
+    {
         Self {
             a,
             f,
-            r: marker::PhantomData,
+            r: PhantomData,
         }
     }
 }
 
-impl<A, F, R> Clone for MapNewService<A, F, R>
+impl<A, F, Response> Clone for MapNewService<A, F, Response>
 where
-    A: NewService + Clone,
-    F: Fn(A::Response) -> R + Clone,
+    A: Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            r: marker::PhantomData,
+            r: PhantomData,
         }
     }
 }
 
-impl<A, F, R> NewService for MapNewService<A, F, R>
+impl<A, F, Request, Response> NewService<Request> for MapNewService<A, F, Response>
 where
-    A: NewService,
-    F: Fn(A::Response) -> R + Clone,
+    A: NewService<Request>,
+    F: Fn(A::Response) -> Response + Clone,
 {
-    type Request = A::Request;
-    type Response = R;
+    type Response = Response;
     type Error = A::Error;
-    type Service = Map<A::Service, F, R>;
+    type Service = Map<A::Service, F, Response>;
 
     type InitError = A::InitError;
-    type Future = MapNewServiceFuture<A, F, R>;
+    type Future = MapNewServiceFuture<A, F, Request, Response>;
 
     fn new_service(&self) -> Self::Future {
         MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
     }
 }
 
-pub struct MapNewServiceFuture<A, F, R>
+pub struct MapNewServiceFuture<A, F, Request, Response>
 where
-    A: NewService,
-    F: Fn(A::Response) -> R,
+    A: NewService<Request>,
+    F: Fn(A::Response) -> Response,
 {
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, R> MapNewServiceFuture<A, F, R>
+impl<A, F, Request, Response> MapNewServiceFuture<A, F, Request, Response>
 where
-    A: NewService,
-    F: Fn(A::Response) -> R,
+    A: NewService<Request>,
+    F: Fn(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapNewServiceFuture { f: Some(f), fut }
     }
 }
 
-impl<A, F, R> Future for MapNewServiceFuture<A, F, R>
+impl<A, F, Request, Response> Future for MapNewServiceFuture<A, F, Request, Response>
 where
-    A: NewService,
-    F: Fn(A::Response) -> R,
+    A: NewService<Request>,
+    F: Fn(A::Response) -> Response,
 {
-    type Item = Map<A::Service, F, R>;
+    type Item = Map<A::Service, F, Response>;
     type Error = A::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
diff --git a/src/service/map_err.rs b/src/service/map_err.rs
index 6bef7c05a..1e8f5de7d 100644
--- a/src/service/map_err.rs
+++ b/src/service/map_err.rs
@@ -1,4 +1,4 @@
-use std::marker;
+use std::marker::PhantomData;
 
 use futures::{Async, Future, Poll};
 
@@ -8,71 +8,71 @@ use super::{NewService, Service};
 /// error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
-pub struct MapErr<A, F, E>
-where
-    A: Service,
-    F: Fn(A::Error) -> E,
-{
+pub struct MapErr<A, F, E> {
     service: A,
     f: F,
+    _t: PhantomData<E>,
 }
 
-impl<A, F, E> MapErr<A, F, E>
-where
-    A: Service,
-    F: Fn(A::Error) -> E,
-{
+impl<A, F, E> MapErr<A, F, E> {
     /// Create new `MapErr` combinator
-    pub fn new(service: A, f: F) -> Self {
-        Self { service, f }
+    pub fn new<Request>(service: A, f: F) -> Self
+    where
+        A: Service<Request>,
+        F: Fn(A::Error) -> E,
+    {
+        Self {
+            service,
+            f,
+            _t: PhantomData,
+        }
     }
 }
 
 impl<A, F, E> Clone for MapErr<A, F, E>
 where
-    A: Service + Clone,
-    F: Fn(A::Error) -> E + Clone,
+    A: Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         MapErr {
             service: self.service.clone(),
             f: self.f.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, F, E> Service for MapErr<A, F, E>
+impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>
 where
-    A: Service,
-    F: Fn(A::Error) -> E,
-    F: Clone,
+    A: Service<Request>,
+    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, F, E, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(&self.f)
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapErrFuture<A, F, E>
+pub struct MapErrFuture<A, F, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     F: Fn(A::Error) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapErrFuture<A, F, E>
+impl<A, F, E, Request> MapErrFuture<A, F, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -80,9 +80,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrFuture<A, F, E>
+impl<A, F, E, Request> Future for MapErrFuture<A, F, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     F: Fn(A::Error) -> E,
 {
     type Item = A::Response;
@@ -100,68 +100,67 @@ where
 pub struct MapErrNewService<A, F, E> {
     a: A,
     f: F,
-    e: marker::PhantomData<E>,
+    e: PhantomData<E>,
 }
 
-impl<A, F, E> MapErrNewService<A, F, E>
-where
-    A: NewService,
-    F: Fn(A::Error) -> E,
-{
+impl<A, F, E> MapErrNewService<A, F, E> {
     /// Create new `MapErr` new service instance
-    pub fn new(a: A, f: F) -> Self {
+    pub fn new<Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        F: Fn(A::Error) -> E,
+    {
         Self {
             a,
             f,
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
 impl<A, F, E> Clone for MapErrNewService<A, F, E>
 where
-    A: NewService + Clone,
-    F: Fn(A::Error) -> E + Clone,
+    A: Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
-impl<A, F, E> NewService for MapErrNewService<A, F, E>
+impl<A, F, E, Request> NewService<Request> for MapErrNewService<A, F, E>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
     type Service = MapErr<A::Service, F, E>;
 
     type InitError = A::InitError;
-    type Future = MapErrNewServiceFuture<A, F, E>;
+    type Future = MapErrNewServiceFuture<A, F, E, Request>;
 
     fn new_service(&self) -> Self::Future {
         MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
     }
 }
 
-pub struct MapErrNewServiceFuture<A, F, E>
+pub struct MapErrNewServiceFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E,
 {
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E> MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, Request> MapErrNewServiceFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -169,9 +168,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, Request> Future for MapErrNewServiceFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E + Clone,
 {
     type Item = MapErr<A::Service, F, E>;
diff --git a/src/service/map_init_err.rs b/src/service/map_init_err.rs
index e6129d29b..40ff97b5f 100644
--- a/src/service/map_init_err.rs
+++ b/src/service/map_init_err.rs
@@ -1,4 +1,4 @@
-use std::marker;
+use std::marker::PhantomData;
 
 use futures::{Future, Poll};
 
@@ -8,68 +8,67 @@ use super::NewService;
 pub struct MapInitErr<A, F, E> {
     a: A,
     f: F,
-    e: marker::PhantomData<E>,
+    e: PhantomData<E>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E>
-where
-    A: NewService,
-    F: Fn(A::InitError) -> E,
-{
+impl<A, F, E> MapInitErr<A, F, E> {
     /// Create new `MapInitErr` combinator
-    pub fn new(a: A, f: F) -> Self {
+    pub fn new<Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        F: Fn(A::InitError) -> E,
+    {
         Self {
             a,
             f,
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
 impl<A, F, E> Clone for MapInitErr<A, F, E>
 where
-    A: NewService + Clone,
-    F: Fn(A::InitError) -> E + Clone,
+    A: Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
-impl<A, F, E> NewService for MapInitErr<A, F, E>
+impl<A, F, E, Request> NewService<Request> for MapInitErr<A, F, E>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type Service = A::Service;
 
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    type Future = MapInitErrFuture<A, F, E, Request>;
 
     fn new_service(&self) -> Self::Future {
         MapInitErrFuture::new(self.a.new_service(), self.f.clone())
     }
 }
 
-pub struct MapInitErrFuture<A, F, E>
+pub struct MapInitErrFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, F, E, Request> MapInitErrFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -77,9 +76,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
+impl<A, F, E, Request> Future for MapInitErrFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E,
 {
     type Item = A::Service;
diff --git a/src/service/mod.rs b/src/service/mod.rs
index f8de56277..e944d29c9 100644
--- a/src/service/mod.rs
+++ b/src/service/mod.rs
@@ -1,7 +1,7 @@
 use futures::{Future, IntoFuture};
 
 /// re-export for convinience
-pub use tower_service::{NewService, Service};
+pub use tower_service::Service;
 
 mod and_then;
 mod apply;
@@ -23,21 +23,20 @@ pub use self::then::{Then, ThenNewService};
 
 /// An extension trait for `Service`s that provides a variety of convenient
 /// adapters
-pub trait ServiceExt: Service {
+pub trait ServiceExt<Request>: Service<Request> {
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply<S, I, F, R>(
+    fn apply<T, I, F, Out, Req>(
         self,
         service: I,
         f: F,
-    ) -> AndThen<Self, Apply<S, F, R, Self::Response>>
+    ) -> AndThen<Self, Apply<T, F, Self::Response, Out, Req>>
     where
         Self: Sized,
-        S: Service,
-        S::Error: Into<<R::Future as Future>::Error>,
-        I: IntoService<S>,
-        F: Fn(Self::Response, &mut S) -> R,
-        R: IntoFuture<Error = Self::Error>,
+        T: Service<Req, Error = Out::Error>,
+        I: IntoService<T, Req>,
+        F: Fn(Self::Response, &mut T) -> Out,
+        Out: IntoFuture<Error = Self::Error>,
     {
         self.and_then(Apply::new(service.into_service(), f))
     }
@@ -54,17 +53,17 @@ pub trait ServiceExt: Service {
     fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
     where
         Self: Sized,
-        F: IntoService<B>,
-        B: Service<Request = Self::Response, Error = Self::Error>,
+        F: IntoService<B, Self::Response>,
+        B: Service<Self::Response, Error = Self::Error>,
     {
         AndThen::new(self, service.into_service())
     }
 
-    /// Map this service's error to any error implementing `From` for
-    /// this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
+    // /// Map this service's error to any error implementing `From` for
+    // /// this service`s `Error`.
+    // ///
+    // /// Note that this function consumes the receiving service and returns a
+    // /// wrapped version of it.
     fn from_err<E>(self) -> FromErr<Self, E>
     where
         Self: Sized,
@@ -73,28 +72,28 @@ pub trait ServiceExt: Service {
         FromErr::new(self)
     }
 
-    /// Chain on a computation for when a call to the service finished,
-    /// passing the result of the call to the next service `B`.
-    ///
-    /// Note that this function consumes the receiving future and returns a
-    /// wrapped version of it.
+    // /// Chain on a computation for when a call to the service finished,
+    // /// passing the result of the call to the next service `B`.
+    // ///
+    // /// Note that this function consumes the receiving future and returns a
+    // /// wrapped version of it.
     fn then<B>(self, service: B) -> Then<Self, B>
     where
         Self: Sized,
-        B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
+        B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
     {
         Then::new(self, service)
     }
 
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    ///
-    /// This function is similar to the `Option::map` or `Iterator::map` where
-    /// it will change the type of the underlying 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.
+    // /// Map this service's output to a different type, returning a new service
+    // /// of the resulting type.
+    // ///
+    // /// This function is similar to the `Option::map` or `Iterator::map` where
+    // /// it will change the type of the underlying 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) -> Map<Self, F, R>
     where
         Self: Sized,
@@ -103,14 +102,14 @@ pub trait ServiceExt: Service {
         Map::new(self, f)
     }
 
-    /// Map this service's error to a different error, returning a new service.
-    ///
-    /// This function is similar to the `Result::map_err` where it will change
-    /// the error type of the underlying service. This is useful for example to
-    /// ensure that services have the same error type.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
+    // /// Map this service's error to a different error, returning a new service.
+    // ///
+    // /// This function is similar to the `Result::map_err` where it will change
+    // /// the error type of the underlying service. This is useful for example to
+    // /// ensure that services have the same error type.
+    // ///
+    // /// Note that this function consumes the receiving service and returns a
+    // /// wrapped version of it.
     fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E>
     where
         Self: Sized,
@@ -120,19 +119,47 @@ pub trait ServiceExt: Service {
     }
 }
 
-pub trait NewServiceExt: NewService {
-    fn apply<S, I, F, R>(
+/// Creates new `Service` values.
+///
+/// Acts as a service factory. This is useful for cases where new `Service`
+/// values must be produced. One case is a TCP servier listener. The listner
+/// accepts new TCP streams, obtains a new `Service` value using the
+/// `NewService` trait, and uses that new `Service` value to process inbound
+/// requests on that new TCP stream.
+///
+/// Request - request handled by the service
+pub trait NewService<Request> {
+    /// Responses given by the service
+    type Response;
+
+    /// Errors produced by the service
+    type Error;
+
+    /// The `Service` value created by this factory
+    type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
+
+    /// Errors produced while building a service.
+    type InitError;
+
+    /// The future of the `Service` instance.
+    type Future: Future<Item = Self::Service, Error = Self::InitError>;
+
+    /// Create and return a new service value asynchronously.
+    fn new_service(&self) -> Self::Future;
+}
+
+pub trait NewServiceExt<Request>: NewService<Request> {
+    fn apply<T, I, F, Out, Req>(
         self,
         service: I,
         f: F,
-    ) -> AndThenNewService<Self, ApplyNewService<S, F, R, Self::Response>>
+    ) -> AndThenNewService<Self, ApplyNewService<T, F, Self::Response, Out, Req>>
     where
         Self: Sized,
-        S: NewService<InitError = Self::InitError>,
-        S::Error: Into<<R::Future as Future>::Error>,
-        I: IntoNewService<S>,
-        F: Fn(Self::Response, &mut S::Service) -> R + Clone,
-        R: IntoFuture<Error = Self::Error>,
+        T: NewService<Req, InitError = Self::InitError, Error = Out::Error>,
+        I: IntoNewService<T, Req>,
+        F: Fn(Self::Response, &mut T::Service) -> Out + Clone,
+        Out: IntoFuture<Error = Self::Error>,
     {
         self.and_then(ApplyNewService::new(service, f))
     }
@@ -140,22 +167,18 @@ pub trait NewServiceExt: NewService {
     fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
     where
         Self: Sized,
-        F: IntoNewService<B>,
-        B: NewService<
-            Request = Self::Response,
-            Error = Self::Error,
-            InitError = Self::InitError,
-        >,
+        F: IntoNewService<B, Self::Response>,
+        B: NewService<Self::Response, Error = Self::Error, InitError = Self::InitError>,
     {
         AndThenNewService::new(self, new_service)
     }
 
-    /// `NewService` that create service to map this service's error
-    /// and new service's init error to any error
-    /// implementing `From` for this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving new service and returns a
-    /// wrapped version of it.
+    // /// `NewService` that create service to map this service's error
+    // /// and new service's init error to any error
+    // /// implementing `From` for this service`s `Error`.
+    // ///
+    // /// Note that this function consumes the receiving new service and returns a
+    // /// wrapped version of it.
     fn from_err<E>(self) -> FromErrNewService<Self, E>
     where
         Self: Sized,
@@ -164,18 +187,18 @@ pub trait NewServiceExt: NewService {
         FromErrNewService::new(self)
     }
 
-    /// Create `NewService` to chain on a computation for when a call to the
-    /// service finished, passing the result of the call to the next
-    /// service `B`.
-    ///
-    /// Note that this function consumes the receiving future and returns a
-    /// wrapped version of it.
+    // /// Create `NewService` to chain on a computation for when a call to the
+    // /// service finished, passing the result of the call to the next
+    // /// service `B`.
+    // ///
+    // /// Note that this function consumes the receiving future and returns a
+    // /// wrapped version of it.
     fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
     where
         Self: Sized,
-        F: IntoNewService<B>,
+        F: IntoNewService<B, Result<Self::Response, Self::Error>>,
         B: NewService<
-            Request = Result<Self::Response, Self::Error>,
+            Result<Self::Response, Self::Error>,
             Error = Self::Error,
             InitError = Self::InitError,
         >,
@@ -208,39 +231,39 @@ pub trait NewServiceExt: NewService {
     }
 }
 
-impl<T: ?Sized> ServiceExt for T where T: Service {}
-impl<T: ?Sized> NewServiceExt for T where T: NewService {}
+impl<T: ?Sized, R> ServiceExt<R> for T where T: Service<R> {}
+impl<T: ?Sized, R> NewServiceExt<R> for T where T: NewService<R> {}
 
 /// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
+pub trait IntoService<T, Request>
 where
-    T: Service,
+    T: Service<Request>,
 {
     /// Convert to a `Service`
     fn into_service(self) -> T;
 }
 
 /// Trait for types that can be converted to a Service
-pub trait IntoNewService<T>
+pub trait IntoNewService<T, Request>
 where
-    T: NewService,
+    T: NewService<Request>,
 {
     /// Convert to an `NewService`
     fn into_new_service(self) -> T;
 }
 
-impl<T> IntoService<T> for T
+impl<T, Request> IntoService<T, Request> for T
 where
-    T: Service,
+    T: Service<Request>,
 {
     fn into_service(self) -> T {
         self
     }
 }
 
-impl<T> IntoNewService<T> for T
+impl<T, Request> IntoNewService<T, Request> for T
 where
-    T: NewService,
+    T: NewService<Request>,
 {
     fn into_new_service(self) -> T {
         self
diff --git a/src/service/then.rs b/src/service/then.rs
index b10537b55..d48ac4b6b 100644
--- a/src/service/then.rs
+++ b/src/service/then.rs
@@ -12,21 +12,21 @@ pub struct Then<A, B> {
     b: Cell<B>,
 }
 
-impl<A, B> Then<A, B>
-where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
-{
+impl<A, B> Then<A, B> {
     /// Create new `Then` combinator
-    pub fn new(a: A, b: B) -> Then<A, B> {
+    pub fn new<Request>(a: A, b: B) -> Then<A, B>
+    where
+        A: Service<Request>,
+        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
+    {
         Then { a, b: Cell::new(b) }
     }
 }
 
 impl<A, B> Clone for Then<A, B>
 where
-    A: Service + Clone,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    A: Clone,
+    B: Clone,
 {
     fn clone(&self) -> Self {
         Then {
@@ -36,40 +36,39 @@ where
     }
 }
 
-impl<A, B> Service for Then<A, B>
+impl<A, B, Request> Service<Request> for Then<A, B>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    A: Service<Request>,
+    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = B::Error;
-    type Future = ThenFuture<A, B>;
+    type Future = ThenFuture<A, B, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         let _ = try_ready!(self.a.poll_ready());
         self.b.borrow_mut().poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         ThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct ThenFuture<A, B>
+pub struct ThenFuture<A, B, Request>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Request>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
     fut_a: A::Future,
 }
 
-impl<A, B> ThenFuture<A, B>
+impl<A, B, Request> ThenFuture<A, B, Request>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Request>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     fn new(fut_a: A::Future, b: Cell<B>) -> Self {
         ThenFuture {
@@ -80,10 +79,10 @@ where
     }
 }
 
-impl<A, B> Future for ThenFuture<A, B>
+impl<A, B, Request> Future for ThenFuture<A, B, Request>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Request>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     type Item = B::Response;
     type Error = B::Error;
@@ -113,13 +112,18 @@ pub struct ThenNewService<A, B> {
     b: B,
 }
 
-impl<A, B> ThenNewService<A, B>
-where
-    A: NewService,
-    B: NewService,
-{
+impl<A, B> ThenNewService<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self {
+    pub fn new<F, Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        B: NewService<
+            Result<A::Response, A::Error>,
+            Error = A::Error,
+            InitError = A::InitError,
+        >,
+        F: IntoNewService<B, Result<A::Response, A::Error>>,
+    {
         Self {
             a,
             b: f.into_new_service(),
@@ -127,22 +131,17 @@ where
     }
 }
 
-impl<A, B> NewService for ThenNewService<A, B>
+impl<A, B, Request> NewService<Request> for ThenNewService<A, B>
 where
-    A: NewService,
-    B: NewService<
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
+    A: NewService<Request>,
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
     type Service = Then<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = ThenNewServiceFuture<A, B>;
+    type Future = ThenNewServiceFuture<A, B, Request>;
 
     fn new_service(&self) -> Self::Future {
         ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@@ -151,12 +150,8 @@ where
 
 impl<A, B> Clone for ThenNewService<A, B>
 where
-    A: NewService + Clone,
-    B: NewService<
-            Request = Result<A::Response, A::Error>,
-            Error = A::Error,
-            InitError = A::InitError,
-        > + Clone,
+    A: Clone,
+    B: Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -166,10 +161,10 @@ where
     }
 }
 
-pub struct ThenNewServiceFuture<A, B>
+pub struct ThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
-    B: NewService,
+    A: NewService<Request>,
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -177,10 +172,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> ThenNewServiceFuture<A, B>
+impl<A, B, Request> ThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
-    B: NewService,
+    A: NewService<Request>,
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         ThenNewServiceFuture {
@@ -192,14 +187,10 @@ where
     }
 }
 
-impl<A, B> Future for ThenNewServiceFuture<A, B>
+impl<A, B, Request> Future for ThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
-    B: NewService<
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
+    A: NewService<Request>,
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
 {
     type Item = Then<A::Service, B::Service>;
     type Error = A::InitError;
diff --git a/src/ssl/nativetls.rs b/src/ssl/nativetls.rs
index 7b9e2cd9c..f5adbc7e9 100644
--- a/src/ssl/nativetls.rs
+++ b/src/ssl/nativetls.rs
@@ -36,8 +36,7 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> {
-    type Request = T;
+impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
     type Response = TlsStream<T>;
     type Error = Error;
     type Service = NativeTlsAcceptorService<T>;
@@ -61,8 +60,7 @@ pub struct NativeTlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
-    type Request = T;
+impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
     type Response = TlsStream<T>;
     type Error = Error;
     type Future = Accept<T>;
@@ -75,7 +73,7 @@ impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         Accept {
             _guard: self.conns.get(),
             inner: Some(self.acceptor.accept(req)),
diff --git a/src/ssl/openssl.rs b/src/ssl/openssl.rs
index b94589276..ada4eaa36 100644
--- a/src/ssl/openssl.rs
+++ b/src/ssl/openssl.rs
@@ -37,8 +37,7 @@ impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
-    type Request = T;
+impl<T: AsyncRead + AsyncWrite> NewService<T> for OpensslAcceptor<T> {
     type Response = SslStream<T>;
     type Error = Error;
     type Service = OpensslAcceptorService<T>;
@@ -62,8 +61,7 @@ pub struct OpensslAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
-    type Request = T;
+impl<T: AsyncRead + AsyncWrite> Service<T> for OpensslAcceptorService<T> {
     type Response = SslStream<T>;
     type Error = Error;
     type Future = OpensslAcceptorServiceFut<T>;
@@ -76,7 +74,7 @@ impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         OpensslAcceptorServiceFut {
             _guard: self.conns.get(),
             fut: SslAcceptorExt::accept_async(&self.acceptor, req),
@@ -119,7 +117,7 @@ impl<R, T, E> OpensslConnector<R, T, E> {
 impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
     pub fn service(
         connector: SslConnector,
-    ) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = Error> {
+    ) -> impl Service<(R, T), Response = (R, SslStream<T>), Error = Error> {
         OpensslConnectorService {
             connector: connector,
             _t: PhantomData,
@@ -136,8 +134,9 @@ impl<R, T, E> Clone for OpensslConnector<R, T, E> {
     }
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<R, T, E> {
-    type Request = (R, T);
+impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<(R, T)>
+    for OpensslConnector<R, T, E>
+{
     type Response = (R, SslStream<T>);
     type Error = Error;
     type Service = OpensslConnectorService<R, T>;
@@ -157,8 +156,9 @@ pub struct OpensslConnectorService<R, T> {
     _t: PhantomData<(R, T)>,
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
-    type Request = (R, T);
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service<(R, T)>
+    for OpensslConnectorService<R, T>
+{
     type Response = (R, SslStream<T>);
     type Error = Error;
     type Future = ConnectAsyncExt<R, T>;
@@ -167,7 +167,7 @@ impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorServ
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, (req, stream): Self::Request) -> Self::Future {
+    fn call(&mut self, (req, stream): (R, T)) -> Self::Future {
         ConnectAsyncExt {
             fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
             req: Some(req),
diff --git a/src/ssl/rustls.rs b/src/ssl/rustls.rs
index 56d3fd95a..5a5b18f0b 100644
--- a/src/ssl/rustls.rs
+++ b/src/ssl/rustls.rs
@@ -38,8 +38,7 @@ impl<T> Clone for RustlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> {
-    type Request = T;
+impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Service = RustlsAcceptorService<T>;
@@ -63,8 +62,7 @@ pub struct RustlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
-    type Request = T;
+impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Future = RustlsAcceptorServiceFut<T>;
@@ -77,7 +75,7 @@ impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         RustlsAcceptorServiceFut {
             _guard: self.conns.get(),
             fut: self.acceptor.accept(req),
diff --git a/src/stream.rs b/src/stream.rs
index 5b08f4415..3f8948ca2 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -17,10 +17,13 @@ pub struct StreamDispatcher<S: Stream, T> {
 impl<S, T> StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Request = Result<S::Item, S::Error>, Response = (), Error = ()>,
+    T: Service<Result<S::Item, S::Error>, Response = (), Error = ()>,
     T::Future: 'static,
 {
-    pub fn new<F: IntoService<T>>(stream: S, service: F) -> Self {
+    pub fn new<F>(stream: S, service: F) -> Self
+    where
+        F: IntoService<T, Result<S::Item, S::Error>>,
+    {
         let (stop_tx, stop_rx) = mpsc::unbounded();
         StreamDispatcher {
             stream,
@@ -35,7 +38,7 @@ where
 impl<S, T> Future for StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Request = Result<S::Item, S::Error>, Response = (), Error = ()>,
+    T: Service<Result<S::Item, S::Error>, Response = (), Error = ()>,
     T::Future: 'static,
 {
     type Item = ();
@@ -109,8 +112,7 @@ impl<T> Clone for TakeItem<T> {
     }
 }
 
-impl<T: Stream> NewService for TakeItem<T> {
-    type Request = T;
+impl<T: Stream> NewService<T> for TakeItem<T> {
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type InitError = ();
@@ -133,8 +135,7 @@ impl<T> Clone for TakeItemService<T> {
     }
 }
 
-impl<T: Stream> Service for TakeItemService<T> {
-    type Request = T;
+impl<T: Stream> Service<T> for TakeItemService<T> {
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type Future = TakeItemServiceResponse<T>;
@@ -143,7 +144,7 @@ impl<T: Stream> Service for TakeItemService<T> {
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         TakeItemServiceResponse { stream: Some(req) }
     }
 }
diff --git a/src/time.rs b/src/time.rs
index 330aacaec..b1ca52fa1 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -43,8 +43,7 @@ impl Default for LowResTime {
     }
 }
 
-impl NewService for LowResTime {
-    type Request = ();
+impl NewService<()> for LowResTime {
     type Response = Instant;
     type Error = Never;
     type InitError = Never;
@@ -88,8 +87,7 @@ impl LowResTimeService {
     }
 }
 
-impl Service for LowResTimeService {
-    type Request = ();
+impl Service<()> for LowResTimeService {
     type Response = Instant;
     type Error = Never;
     type Future = FutureResult<Self::Response, Self::Error>;
diff --git a/src/timeout.rs b/src/timeout.rs
index 98398c249..ee7053dc4 100644
--- a/src/timeout.rs
+++ b/src/timeout.rs
@@ -12,7 +12,7 @@ use service::{NewService, Service};
 
 /// Applies a timeout to requests.
 #[derive(Debug)]
-pub struct Timeout<T: NewService + Clone> {
+pub struct Timeout<T> {
     inner: T,
     timeout: Duration,
 }
@@ -34,25 +34,24 @@ impl<E: fmt::Debug> fmt::Debug for TimeoutError<E> {
     }
 }
 
-impl<T> Timeout<T>
-where
-    T: NewService + Clone,
-{
-    pub fn new(timeout: Duration, inner: T) -> Self {
+impl<T> Timeout<T> {
+    pub fn new<Request>(timeout: Duration, inner: T) -> Self
+    where
+        T: NewService<Request> + Clone,
+    {
         Timeout { inner, timeout }
     }
 }
 
-impl<T> NewService for Timeout<T>
+impl<T, Request> NewService<Request> for Timeout<T>
 where
-    T: NewService + Clone,
+    T: NewService<Request> + Clone,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = TimeoutError<T::Error>;
     type InitError = T::InitError;
     type Service = TimeoutService<T::Service>;
-    type Future = TimeoutFut<T>;
+    type Future = TimeoutFut<T, Request>;
 
     fn new_service(&self) -> Self::Future {
         TimeoutFut {
@@ -64,14 +63,14 @@ where
 
 /// `Timeout` response future
 #[derive(Debug)]
-pub struct TimeoutFut<T: NewService> {
+pub struct TimeoutFut<T: NewService<Request>, Request> {
     fut: T::Future,
     timeout: Duration,
 }
 
-impl<T> Future for TimeoutFut<T>
+impl<T, Request> Future for TimeoutFut<T, Request>
 where
-    T: NewService,
+    T: NewService<Request>,
 {
     type Item = TimeoutService<T::Service>;
     type Error = T::InitError;
@@ -90,15 +89,15 @@ pub struct TimeoutService<T> {
 }
 
 impl<T> TimeoutService<T> {
-    pub fn new(timeout: Duration, inner: T) -> Self {
+    pub fn new<Request>(timeout: Duration, inner: T) -> Self
+    where
+        T: Service<Request>,
+    {
         TimeoutService { inner, timeout }
     }
 }
 
-impl<T> Clone for TimeoutService<T>
-where
-    T: Clone,
-{
+impl<T: Clone> Clone for TimeoutService<T> {
     fn clone(&self) -> Self {
         TimeoutService {
             inner: self.inner.clone(),
@@ -107,14 +106,13 @@ where
     }
 }
 
-impl<T> Service for TimeoutService<T>
+impl<T, Request> Service<Request> for TimeoutService<T>
 where
-    T: Service,
+    T: Service<Request>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = TimeoutError<T::Error>;
-    type Future = TimeoutServiceResponse<T>;
+    type Future = TimeoutServiceResponse<T, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.inner
@@ -122,7 +120,7 @@ where
             .map_err(|e| TimeoutError::Service(e))
     }
 
-    fn call(&mut self, request: Self::Request) -> Self::Future {
+    fn call(&mut self, request: Request) -> Self::Future {
         TimeoutServiceResponse {
             fut: self.inner.call(request),
             sleep: Delay::new(clock::now() + self.timeout),
@@ -132,14 +130,14 @@ where
 
 /// `TimeoutService` response future
 #[derive(Debug)]
-pub struct TimeoutServiceResponse<T: Service> {
+pub struct TimeoutServiceResponse<T: Service<Request>, Request> {
     fut: T::Future,
     sleep: Delay,
 }
 
-impl<T> Future for TimeoutServiceResponse<T>
+impl<T, Request> Future for TimeoutServiceResponse<T, Request>
 where
-    T: Service,
+    T: Service<Request>,
 {
     type Item = T::Response;
     type Error = TimeoutError<T::Error>;