diff --git a/ntex-io/src/dispatcher.rs b/ntex-io/src/dispatcher.rs
index 6dca4d6d..46f33e3e 100644
--- a/ntex-io/src/dispatcher.rs
+++ b/ntex-io/src/dispatcher.rs
@@ -518,11 +518,11 @@ mod tests {
 
     impl<S, U> Dispatcher<S, U>
     where
-        S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static,
+        S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
         U: Decoder + Encoder + 'static,
     {
         /// Construct new `Dispatcher` instance
-        pub(crate) fn debug<T: IoStream, F: IntoService<S>>(
+        pub(crate) fn debug<T: IoStream, F: IntoService<S, DispatchItem<U>>>(
             io: T,
             codec: U,
             service: F,
@@ -682,8 +682,7 @@ mod tests {
 
         struct Srv(Rc<Cell<usize>>);
 
-        impl Service for Srv {
-            type Request = DispatchItem<BytesCodec>;
+        impl Service<DispatchItem<BytesCodec>> for Srv {
             type Response = Option<Response<BytesCodec>>;
             type Error = ();
             type Future = Ready<Option<Response<BytesCodec>>, ()>;
diff --git a/ntex/src/http/h1/dispatcher.rs b/ntex/src/http/h1/dispatcher.rs
index 3c55acc5..6299b35f 100644
--- a/ntex/src/http/h1/dispatcher.rs
+++ b/ntex/src/http/h1/dispatcher.rs
@@ -654,8 +654,8 @@ mod tests {
         service: F,
     ) -> Dispatcher<Base, S, B, ExpectHandler, UpgradeHandler<Base>>
     where
-        F: IntoService<S>,
-        S: Service<Request = Request>,
+        F: IntoService<S, Request>,
+        S: Service<Request>,
         S::Error: ResponseError + 'static,
         S::Response: Into<Response<B>>,
         B: MessageBody,
@@ -680,8 +680,8 @@ mod tests {
 
     pub(crate) fn spawn_h1<F, S, B>(stream: Io, service: F)
     where
-        F: IntoService<S>,
-        S: Service<Request = Request> + 'static,
+        F: IntoService<S, Request>,
+        S: Service<Request> + 'static,
         S::Error: ResponseError,
         S::Response: Into<Response<B>>,
         B: MessageBody + 'static,
diff --git a/ntex/src/server/worker.rs b/ntex/src/server/worker.rs
index b912ce0e..84057c16 100644
--- a/ntex/src/server/worker.rs
+++ b/ntex/src/server/worker.rs
@@ -514,12 +514,10 @@ mod tests {
         counter: Arc<Mutex<usize>>,
     }
 
-    impl ServiceFactory for SrvFactory {
-        type Request = Io;
+    impl ServiceFactory<Io> for SrvFactory {
         type Response = ();
         type Error = ();
         type Service = Srv;
-        type Config = ();
         type InitError = ();
         type Future = Ready<Srv, ()>;
 
@@ -536,8 +534,7 @@ mod tests {
         st: Arc<Mutex<St>>,
     }
 
-    impl Service for Srv {
-        type Request = Io;
+    impl Service<Io> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<(), ()>;
diff --git a/ntex/src/util/buffer.rs b/ntex/src/util/buffer.rs
index a2c49098..3d56a8c6 100644
--- a/ntex/src/util/buffer.rs
+++ b/ntex/src/util/buffer.rs
@@ -244,8 +244,7 @@ mod tests {
         count: Cell<usize>,
     }
 
-    impl Service for TestService {
-        type Request = ();
+    impl Service<()> for TestService {
         type Response = ();
         type Error = ();
         type Future = Ready<(), ()>;
diff --git a/ntex/src/util/inflight.rs b/ntex/src/util/inflight.rs
index b2c3bfc5..dd831c2d 100644
--- a/ntex/src/util/inflight.rs
+++ b/ntex/src/util/inflight.rs
@@ -117,8 +117,7 @@ mod tests {
 
     struct SleepService(Duration);
 
-    impl Service for SleepService {
-        type Request = ();
+    impl Service<()> for SleepService {
         type Response = ();
         type Error = ();
         type Future = Pin<Box<dyn Future<Output = Result<(), ()>>>>;
diff --git a/ntex/src/util/keepalive.rs b/ntex/src/util/keepalive.rs
index 7ce7f80a..730ad2b5 100644
--- a/ntex/src/util/keepalive.rs
+++ b/ntex/src/util/keepalive.rs
@@ -7,13 +7,13 @@ use crate::{util::Ready, Service, ServiceFactory};
 /// KeepAlive service factory
 ///
 /// Controls min time between requests.
-pub struct KeepAlive<E, F> {
+pub struct KeepAlive<R, E, F> {
     f: F,
     ka: Millis,
-    _t: marker::PhantomData<E>,
+    _t: marker::PhantomData<(R, E)>,
 }
 
-impl<E, F> KeepAlive<E, F>
+impl<R, E, F> KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
 {
@@ -30,7 +30,7 @@ where
     }
 }
 
-impl<E, F> Clone for KeepAlive<E, F>
+impl<R, E, F> Clone for KeepAlive<R, E, F>
 where
     F: Clone,
 {
@@ -43,14 +43,14 @@ where
     }
 }
 
-impl<R, E, F, C> ServiceFactory<R, C> for KeepAlive<E, F>
+impl<R, E, F, C> ServiceFactory<R, C> for KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
 {
     type Response = R;
     type Error = E;
     type InitError = Infallible;
-    type Service = KeepAliveService<E, F>;
+    type Service = KeepAliveService<R, E, F>;
     type Future = Ready<Self::Service, Self::InitError>;
 
     #[inline]
@@ -59,15 +59,15 @@ where
     }
 }
 
-pub struct KeepAliveService<E, F> {
+pub struct KeepAliveService<R, E, F> {
     f: F,
     dur: Millis,
     sleep: Sleep,
     expire: Cell<Instant>,
-    _t: marker::PhantomData<E>,
+    _t: marker::PhantomData<(R, E)>,
 }
 
-impl<E, F> KeepAliveService<E, F>
+impl<R, E, F> KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
@@ -84,7 +84,7 @@ where
     }
 }
 
-impl<R, E, F> Service<R> for KeepAliveService<E, F>
+impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
diff --git a/ntex/src/util/mod.rs b/ntex/src/util/mod.rs
index 186c4bfa..78f93004 100644
--- a/ntex/src/util/mod.rs
+++ b/ntex/src/util/mod.rs
@@ -6,7 +6,7 @@ pub mod keepalive;
 pub mod sink;
 pub mod stream;
 pub mod timeout;
-//pub mod variant;
+pub mod variant;
 
 pub use self::extensions::Extensions;
 
diff --git a/ntex/src/util/timeout.rs b/ntex/src/util/timeout.rs
index 6ad8b5cd..785874dc 100644
--- a/ntex/src/util/timeout.rs
+++ b/ntex/src/util/timeout.rs
@@ -228,8 +228,7 @@ mod tests {
     #[derive(Clone, Debug, Display, PartialEq)]
     struct SrvError;
 
-    impl Service for SleepService {
-        type Request = ();
+    impl Service<()> for SleepService {
         type Response = ();
         type Error = SrvError;
         type Future = Pin<Box<dyn Future<Output = Result<(), SrvError>>>>;
diff --git a/ntex/src/util/variant.rs b/ntex/src/util/variant.rs
index d0f76e4d..a7a6ce75 100644
--- a/ntex/src/util/variant.rs
+++ b/ntex/src/util/variant.rs
@@ -6,7 +6,9 @@ use crate::service::{IntoServiceFactory, Service, ServiceFactory};
 /// Construct `Variant` service factory.
 ///
 /// Variant service allow to combine multiple different services into a single service.
-pub fn variant<V1: ServiceFactory<V1R>, V1R>(factory: V1) -> Variant<V1, V1R> {
+pub fn variant<V1: ServiceFactory<V1R, V1C>, V1R, V1C>(
+    factory: V1,
+) -> Variant<V1, V1R, V1C> {
     Variant {
         factory,
         _t: PhantomData,
@@ -14,27 +16,27 @@ pub fn variant<V1: ServiceFactory<V1R>, V1R>(factory: V1) -> Variant<V1, V1R> {
 }
 
 /// Combine multiple different service types into a single service.
-pub struct Variant<A, AR> {
+pub struct Variant<A, AR, AC> {
     factory: A,
-    _t: PhantomData<AR>,
+    _t: PhantomData<(AR, AC)>,
 }
 
-impl<A, AR> Variant<A, AR>
+impl<A, AR, AC> Variant<A, AR, AC>
 where
-    A: ServiceFactory<AR>,
-    A::Config: Clone,
+    A: ServiceFactory<AR, AC>,
+    AC: Clone,
 {
     /// Convert to a Variant with two request types
-    pub fn v2<B, BR, F>(self, factory: F) -> VariantFactory2<A, B, AR, BR>
+    pub fn v2<B, BR, F>(self, factory: F) -> VariantFactory2<A, AC, B, AR, BR>
     where
         B: ServiceFactory<
             BR,
-            Config = A::Config,
+            AC,
             Response = A::Response,
             Error = A::Error,
             InitError = A::InitError,
         >,
-        F: IntoServiceFactory<B, BR>,
+        F: IntoServiceFactory<B, BR, AC>,
     {
         VariantFactory2 {
             V1: self.factory,
@@ -47,19 +49,18 @@ where
 macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident, $r_name:ident, $m_name:ident, ($($T:ident),+), ($($R:ident),+)} => {
 
     #[allow(non_snake_case)]
-    impl<V1, $($T,)+ V1R, $($R,)+> $fac1_type<V1, $($T,)+ V1R, $($R,)+>
+    impl<V1, V1C, $($T,)+ V1R, $($R,)+> $fac1_type<V1, V1C, $($T,)+ V1R, $($R,)+>
         where
-            V1: ServiceFactory<V1R>,
-            V1::Config: Clone,
+            V1: ServiceFactory<V1R, V1C>,
+            V1C: Clone,
         {
             /// Convert to a Variant with more request types
-            pub fn $m_name<$name, $r_name, F>(self, factory: F) -> $fac2_type<V1, $($T,)+ $name, V1R, $($R,)+ $r_name>
-            where $name: ServiceFactory<$r_name,
-                    Config = V1::Config,
+            pub fn $m_name<$name, $r_name, F>(self, factory: F) -> $fac2_type<V1, V1C, $($T,)+ $name, V1R, $($R,)+ $r_name>
+            where $name: ServiceFactory<$r_name, V1C,
                     Response = V1::Response,
                     Error = V1::Error,
                     InitError = V1::InitError>,
-                F: IntoServiceFactory<$name, $r_name>,
+                F: IntoServiceFactory<$name, $r_name, V1C>,
             {
                 $fac2_type {
                     V1: self.V1,
@@ -136,13 +137,13 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
     }
 
     #[allow(non_snake_case)]
-    pub struct $fac_type<V1, $($T,)+ V1R, $($R,)+> {
+    pub struct $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
         V1: V1,
         $($T: $T,)+
-        _t: PhantomData<(V1R, $($R,)+)>,
+        _t: PhantomData<(V1C, V1R, $($R,)+)>,
     }
 
-    impl<V1: Clone, $($T: Clone,)+ V1R, $($R,)+> Clone for $fac_type<V1, $($T,)+ V1R, $($R,)+> {
+    impl<V1: Clone, V1C, $($T: Clone,)+ V1R, $($R,)+> Clone for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
         fn clone(&self) -> Self {
             Self {
                 _t: PhantomData,
@@ -152,20 +153,19 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
         }
     }
 
-    impl<V1, $($T,)+ V1R, $($R,)+> ServiceFactory<$enum_type<V1R, $($R),+>> for $fac_type<V1, $($T,)+ V1R, $($R,)+>
+    impl<V1, V1C, $($T,)+ V1R, $($R,)+> ServiceFactory<$enum_type<V1R, $($R),+>, V1C> for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+>
     where
-        V1: ServiceFactory<V1R>,
-        V1::Config: Clone,
-        $($T: ServiceFactory<$R, Config = V1::Config, Response = V1::Response, Error = V1::Error, InitError = V1::InitError>),+
+        V1: ServiceFactory<V1R, V1C>,
+        V1C: Clone,
+        $($T: ServiceFactory<$R, V1C, Response = V1::Response, Error = V1::Error, InitError = V1::InitError>),+
     {
         type Response = V1::Response;
         type Error = V1::Error;
-        type Config = V1::Config;
         type InitError = V1::InitError;
         type Service = $srv_type<V1::Service, $($T::Service,)+ V1R, $($R,)+>;
-        type Future = $mod_name::ServiceFactoryResponse<V1, $($T,)+ V1R, $($R,)+>;
+        type Future = $mod_name::ServiceFactoryResponse<V1, V1C, $($T,)+ V1R, $($R,)+>;
 
-        fn new_service(&self, cfg: Self::Config) -> Self::Future {
+        fn new_service(&self, cfg: V1C) -> Self::Future {
             $mod_name::ServiceFactoryResponse {
                 V1: None,
                 items: Default::default(),
@@ -206,7 +206,7 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
 
         pin_project_lite::pin_project! {
             #[doc(hidden)]
-            pub struct ServiceFactoryResponse<V1: ServiceFactory<V1R>, $($T: ServiceFactory<$R>,)+ V1R, $($R,)+> {
+            pub struct ServiceFactoryResponse<V1: ServiceFactory<V1R, V1C>, V1C, $($T: ServiceFactory<$R, V1C>,)+ V1R, $($R,)+> {
                 pub(super) V1: Option<V1::Service>,
                 pub(super) items: ($(Option<$T::Service>,)+),
                 #[pin] pub(super) V1_fut: V1::Future,
@@ -214,10 +214,10 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
             }
         }
 
-        impl<V1, $($T,)+ V1R, $($R,)+> Future for ServiceFactoryResponse<V1, $($T,)+ V1R, $($R,)+>
+        impl<V1, V1C, $($T,)+ V1R, $($R,)+> Future for ServiceFactoryResponse<V1, V1C, $($T,)+ V1R, $($R,)+>
         where
-            V1: ServiceFactory<V1R>,
-        $($T: ServiceFactory<$R, Response = V1::Response, Error = V1::Error, InitError = V1::InitError,>),+
+            V1: ServiceFactory<V1R, V1C>,
+        $($T: ServiceFactory<$R, V1C, Response = V1::Response, Error = V1::Error, InitError = V1::InitError,>),+
         {
             type Output = Result<$srv_type<V1::Service, $($T::Service,)+ V1R, $($R),+>, V1::InitError>;
 
@@ -301,8 +301,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv1;
 
-    impl Service for Srv1 {
-        type Request = ();
+    impl Service<()> for Srv1 {
         type Response = usize;
         type Error = ();
         type Future = Ready<usize, ()>;
@@ -323,8 +322,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv2;
 
-    impl Service for Srv2 {
-        type Request = ();
+    impl Service<()> for Srv2 {
         type Response = usize;
         type Error = ();
         type Future = Ready<usize, ()>;
diff --git a/ntex/src/web/middleware/compress.rs b/ntex/src/web/middleware/compress.rs
index 1a3c85ed..a32d47b4 100644
--- a/ntex/src/web/middleware/compress.rs
+++ b/ntex/src/web/middleware/compress.rs
@@ -26,50 +26,40 @@ use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
 ///         );
 /// }
 /// ```
-pub struct Compress<E> {
+pub struct Compress {
     enc: ContentEncoding,
-    _t: marker::PhantomData<E>,
 }
 
-impl<E> Compress<E> {
+impl Compress {
     /// Create new `Compress` middleware with default encoding.
     pub fn new(encoding: ContentEncoding) -> Self {
-        Compress {
-            enc: encoding,
-            _t: marker::PhantomData,
-        }
+        Compress { enc: encoding }
     }
 }
 
-impl<E> Default for Compress<E> {
+impl Default for Compress {
     fn default() -> Self {
         Compress::new(ContentEncoding::Auto)
     }
 }
 
-impl<S, E> Transform<S> for Compress<E>
-where
-    S: Service<WebRequest<E>, Response = WebResponse>,
-    E: ErrorRenderer,
-{
-    type Service = CompressMiddleware<S, E>;
+impl<S> Transform<S> for Compress {
+    type Service = CompressMiddleware<S>;
 
     fn new_transform(&self, service: S) -> Self::Service {
         CompressMiddleware {
             service,
             encoding: self.enc,
-            _t: marker::PhantomData,
         }
     }
 }
 
-pub struct CompressMiddleware<S, E> {
+pub struct CompressMiddleware<S> {
     service: S,
     encoding: ContentEncoding,
-    _t: marker::PhantomData<E>,
 }
 
-impl<S, E> Service<WebRequest<E>> for CompressMiddleware<S, E>
+impl<S, E> Service<WebRequest<E>> for CompressMiddleware<S>
 where
     S: Service<WebRequest<E>, Response = WebResponse>,
     E: ErrorRenderer,
diff --git a/ntex/src/web/middleware/defaultheaders.rs b/ntex/src/web/middleware/defaultheaders.rs
index bdbf084d..ce703aa0 100644
--- a/ntex/src/web/middleware/defaultheaders.rs
+++ b/ntex/src/web/middleware/defaultheaders.rs
@@ -1,6 +1,6 @@
 //! Middleware for setting default response headers
 use std::task::{Context, Poll};
-use std::{convert::TryFrom, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
+use std::{convert::TryFrom, future::Future, pin::Pin, rc::Rc};
 
 use crate::http::error::HttpError;
 use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
@@ -26,9 +26,8 @@ use crate::web::{WebRequest, WebResponse};
 /// }
 /// ```
 #[derive(Clone)]
-pub struct DefaultHeaders<E> {
+pub struct DefaultHeaders {
     inner: Rc<Inner>,
-    _t: PhantomData<E>,
 }
 
 struct Inner {
@@ -36,21 +35,20 @@ struct Inner {
     headers: HeaderMap,
 }
 
-impl<E> Default for DefaultHeaders<E> {
+impl Default for DefaultHeaders {
     fn default() -> Self {
         DefaultHeaders {
             inner: Rc::new(Inner {
                 ct: false,
                 headers: HeaderMap::new(),
             }),
-            _t: PhantomData,
         }
     }
 }
 
-impl<E> DefaultHeaders<E> {
+impl DefaultHeaders {
     /// Construct `DefaultHeaders` middleware.
-    pub fn new() -> DefaultHeaders<E> {
+    pub fn new() -> DefaultHeaders {
         DefaultHeaders::default()
     }
 
@@ -88,29 +86,23 @@ impl<E> DefaultHeaders<E> {
     }
 }
 
-impl<S, E> Transform<S> for DefaultHeaders<E>
-where
-    S: Service<WebRequest<E>, Response = WebResponse>,
-    S::Future: 'static,
-{
-    type Service = DefaultHeadersMiddleware<S, E>;
+impl<S> Transform<S> for DefaultHeaders {
+    type Service = DefaultHeadersMiddleware<S>;
 
     fn new_transform(&self, service: S) -> Self::Service {
         DefaultHeadersMiddleware {
             service,
             inner: self.inner.clone(),
-            _t: PhantomData,
         }
     }
 }
 
-pub struct DefaultHeadersMiddleware<S, E> {
+pub struct DefaultHeadersMiddleware<S> {
     service: S,
     inner: Rc<Inner>,
-    _t: PhantomData<E>,
 }
 
-impl<S, E> Service<WebRequest<E>> for DefaultHeadersMiddleware<S, E>
+impl<S, E> Service<WebRequest<E>> for DefaultHeadersMiddleware<S>
 where
     S: Service<WebRequest<E>, Response = WebResponse>,
     S::Future: 'static,
diff --git a/ntex/tests/http_ws.rs b/ntex/tests/http_ws.rs
index 3be579bb..8399aad0 100644
--- a/ntex/tests/http_ws.rs
+++ b/ntex/tests/http_ws.rs
@@ -31,8 +31,7 @@ impl Clone for WsService {
     }
 }
 
-impl Service for WsService {
-    type Request = (Request, Io, h1::Codec);
+impl Service<(Request, Io, h1::Codec)> for WsService {
     type Response = ();
     type Error = io::Error;
     type Future = Pin<Box<dyn Future<Output = Result<(), io::Error>>>>;
@@ -42,7 +41,7 @@ impl Service for WsService {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&self, (req, io, codec): Self::Request) -> Self::Future {
+    fn call(&self, (req, io, codec): (Request, Io, h1::Codec)) -> Self::Future {
         let fut = async move {
             let res = handshake(req.head()).unwrap().message_body(());