diff --git a/ntex-service/Cargo.toml b/ntex-service/Cargo.toml
index 1cbf71e0..4ed29b17 100644
--- a/ntex-service/Cargo.toml
+++ b/ntex-service/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "0.3.2"
+version = "0.3.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]
@@ -20,4 +20,4 @@ pin-project-lite = "0.2.6"
 
 [dev-dependencies]
 ntex = { version = "0.5", features = ["tokio"] }
-ntex-util = "0.1.13"
+ntex-util = "0.1.5"
diff --git a/ntex-service/src/and_then.rs b/ntex-service/src/and_then.rs
index b248187a..a9643257 100644
--- a/ntex-service/src/and_then.rs
+++ b/ntex-service/src/and_then.rs
@@ -126,20 +126,27 @@ where
 }
 
 /// `.and_then()` service factory combinator
-pub struct AndThenFactory<A, B> {
+pub struct AndThenFactory<A, B, Req, Cfg> {
     inner: Rc<(A, B)>,
+    _t: PhantomData<fn(Req, Cfg)>,
 }
 
-impl<A, B> AndThenFactory<A, B> {
+impl<A, B, Req, Cfg> AndThenFactory<A, B, Req, Cfg>
+where
+    A: ServiceFactory<Req, Cfg>,
+    B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
+    Cfg: Clone,
+{
     /// Create new `AndThenFactory` combinator
-    pub fn new(a: A, b: B) -> Self {
+    pub(crate) fn new(a: A, b: B) -> Self {
         Self {
             inner: Rc::new((a, b)),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, B, Req, Cfg> ServiceFactory<Req, Cfg> for AndThenFactory<A, B>
+impl<A, B, Req, Cfg> ServiceFactory<Req, Cfg> for AndThenFactory<A, B, Req, Cfg>
 where
     A: ServiceFactory<Req, Cfg>,
     B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
@@ -150,27 +157,28 @@ where
 
     type Service = AndThen<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = AndThenFactoryResponse<A, B, Req, Cfg>;
+    type Future = AndThenServiceFactoryResponse<A, B, Req, Cfg>;
 
     fn new_service(&self, cfg: Cfg) -> Self::Future {
         let inner = &*self.inner;
-        AndThenFactoryResponse::new(
+        AndThenServiceFactoryResponse::new(
             inner.0.new_service(cfg.clone()),
             inner.1.new_service(cfg),
         )
     }
 }
 
-impl<A, B> Clone for AndThenFactory<A, B> {
+impl<A, B, Req, Cfg> Clone for AndThenFactory<A, B, Req, Cfg> {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
+            _t: PhantomData,
         }
     }
 }
 
 pin_project_lite::pin_project! {
-    pub struct AndThenFactoryResponse<A, B, Req, Cfg>
+    pub struct AndThenServiceFactoryResponse<A, B, Req, Cfg>
     where
         A: ServiceFactory<Req, Cfg>,
         B: ServiceFactory<A::Response, Cfg>,
@@ -185,13 +193,13 @@ pin_project_lite::pin_project! {
     }
 }
 
-impl<A, B, Req, Cfg> AndThenFactoryResponse<A, B, Req, Cfg>
+impl<A, B, Req, Cfg> AndThenServiceFactoryResponse<A, B, Req, Cfg>
 where
     A: ServiceFactory<Req, Cfg>,
     B: ServiceFactory<A::Response, Cfg>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
-        AndThenFactoryResponse {
+        AndThenServiceFactoryResponse {
             fut_a,
             fut_b,
             a: None,
@@ -200,7 +208,7 @@ where
     }
 }
 
-impl<A, B, Req, Cfg> Future for AndThenFactoryResponse<A, B, Req, Cfg>
+impl<A, B, Req, Cfg> Future for AndThenServiceFactoryResponse<A, B, Req, Cfg>
 where
     A: ServiceFactory<Req, Cfg>,
     B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
diff --git a/ntex-service/src/lib.rs b/ntex-service/src/lib.rs
index f44a9d45..a649e1cd 100644
--- a/ntex-service/src/lib.rs
+++ b/ntex-service/src/lib.rs
@@ -135,7 +135,7 @@ pub trait Service<Req> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
+    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
@@ -185,17 +185,23 @@ pub trait ServiceFactory<Req, Cfg = ()> {
 
     #[inline]
     /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, Cfg, F, E>
+    fn map_err<F, E>(
+        self,
+        f: F,
+    ) -> crate::map_err::MapErrServiceFactory<Self, Req, Cfg, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E + Clone,
     {
-        crate::map_err::MapErrServiceFactory::new(self, f)
+        crate::map_err::MapErrServiceFactory::<_, _, Cfg, _, _>::new(self, f)
     }
 
     #[inline]
     /// Map this factory's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
+    fn map_init_err<F, E>(
+        self,
+        f: F,
+    ) -> crate::map_init_err::MapInitErr<Self, Req, Cfg, F, E>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E + Clone,
diff --git a/ntex-service/src/map_err.rs b/ntex-service/src/map_err.rs
index 07ed063e..b581013e 100644
--- a/ntex-service/src/map_err.rs
+++ b/ntex-service/src/map_err.rs
@@ -6,15 +6,19 @@ use super::{Service, ServiceFactory};
 /// error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
-pub struct MapErr<A, F, E> {
+pub struct MapErr<A, R, F, E> {
     service: A,
     f: F,
-    _t: PhantomData<E>,
+    _t: PhantomData<fn(R) -> E>,
 }
 
-impl<A, F, E> MapErr<A, F, E> {
+impl<A, R, F, E> MapErr<A, R, F, E> {
     /// Create new `MapErr` combinator
-    pub(crate) fn new(service: A, f: F) -> Self {
+    pub(crate) fn new(service: A, f: F) -> Self
+    where
+        A: Service<R>,
+        F: Fn(A::Error) -> E,
+    {
         Self {
             service,
             f,
@@ -23,7 +27,7 @@ impl<A, F, E> MapErr<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapErr<A, F, E>
+impl<A, R, F, E> Clone for MapErr<A, R, F, E>
 where
     A: Clone,
     F: Clone,
@@ -38,7 +42,7 @@ where
     }
 }
 
-impl<A, R, F, E> Service<R> for MapErr<A, F, E>
+impl<A, R, F, E> Service<R> for MapErr<A, R, F, E>
 where
     A: Service<R>,
     F: Fn(A::Error) -> E + Clone,
@@ -102,13 +106,21 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrServiceFactory<A, C, F, E> {
+pub struct MapErrServiceFactory<A, R, C, F, E>
+where
+    A: ServiceFactory<R, C>,
+    F: Fn(A::Error) -> E + Clone,
+{
     a: A,
     f: F,
-    e: PhantomData<(C, E)>,
+    e: PhantomData<fn(R, C) -> E>,
 }
 
-impl<A, C, F, E> MapErrServiceFactory<A, C, F, E> {
+impl<A, R, C, F, E> MapErrServiceFactory<A, R, C, F, E>
+where
+    A: ServiceFactory<R, C>,
+    F: Fn(A::Error) -> E + Clone,
+{
     /// Create new `MapErr` new service instance
     pub(crate) fn new(a: A, f: F) -> Self {
         Self {
@@ -119,10 +131,10 @@ impl<A, C, F, E> MapErrServiceFactory<A, C, F, E> {
     }
 }
 
-impl<A, C, F, E> Clone for MapErrServiceFactory<A, C, F, E>
+impl<A, R, C, F, E> Clone for MapErrServiceFactory<A, R, C, F, E>
 where
-    A: Clone,
-    F: Clone,
+    A: ServiceFactory<R, C> + Clone,
+    F: Fn(A::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -133,7 +145,7 @@ where
     }
 }
 
-impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, C, F, E>
+impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrServiceFactory<A, R, C, F, E>
 where
     A: ServiceFactory<R, C>,
     F: Fn(A::Error) -> E + Clone,
@@ -141,7 +153,7 @@ where
     type Response = A::Response;
     type Error = E;
 
-    type Service = MapErr<A::Service, F, E>;
+    type Service = MapErr<A::Service, R, F, E>;
     type InitError = A::InitError;
     type Future = MapErrServiceFuture<A, R, C, F, E>;
 
@@ -178,7 +190,7 @@ where
     A: ServiceFactory<R, C>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
+    type Output = Result<MapErr<A::Service, R, F, E>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
diff --git a/ntex-service/src/map_init_err.rs b/ntex-service/src/map_init_err.rs
index 167b7c64..f37b57f6 100644
--- a/ntex-service/src/map_init_err.rs
+++ b/ntex-service/src/map_init_err.rs
@@ -3,13 +3,17 @@ use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Po
 use super::ServiceFactory;
 
 /// `MapInitErr` service combinator
-pub struct MapInitErr<A, F, E> {
+pub struct MapInitErr<A, R, C, F, E> {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<fn(R, C) -> E>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E> {
+impl<A, R, C, F, E> MapInitErr<A, R, C, F, E>
+where
+    A: ServiceFactory<R, C>,
+    F: Fn(A::InitError) -> E,
+{
     /// Create new `MapInitErr` combinator
     pub(crate) fn new(a: A, f: F) -> Self {
         Self {
@@ -20,7 +24,7 @@ impl<A, F, E> MapInitErr<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapInitErr<A, F, E>
+impl<A, R, C, F, E> Clone for MapInitErr<A, R, C, F, E>
 where
     A: Clone,
     F: Clone,
@@ -34,7 +38,7 @@ where
     }
 }
 
-impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, F, E>
+impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
 where
     A: ServiceFactory<R, C>,
     F: Fn(A::InitError) -> E + Clone,
@@ -44,7 +48,7 @@ where
 
     type Service = A::Service;
     type InitError = E;
-    type Future = MapInitErrFuture<A::Future, A::Service, A::InitError, F, E>;
+    type Future = MapInitErrFuture<A, R, C, F, E>;
 
     fn new_service(&self, cfg: C) -> Self::Future {
         MapInitErrFuture {
@@ -55,23 +59,23 @@ where
 }
 
 pin_project_lite::pin_project! {
-    pub struct MapInitErrFuture<Fut, Srv, Err, F, E>
+    pub struct MapInitErrFuture<A, R, C, F, E>
     where
-        F: Fn(Err) -> E,
-        Fut: Future<Output = Result<Srv, Err>>,
+        A: ServiceFactory<R, C>,
+        F: Fn(A::InitError) -> E,
     {
         f: F,
         #[pin]
-        fut: Fut,
+        fut: A::Future,
     }
 }
 
-impl<Fut, Srv, Err, F, E> Future for MapInitErrFuture<Fut, Srv, Err, F, E>
+impl<A, R, C, F, E> Future for MapInitErrFuture<A, R, C, F, E>
 where
-    F: Fn(Err) -> E,
-    Fut: Future<Output = Result<Srv, Err>>,
+    A: ServiceFactory<R, C>,
+    F: Fn(A::InitError) -> E,
 {
-    type Output = Result<Srv, E>;
+    type Output = Result<A::Service, E>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
diff --git a/ntex-service/src/pipeline.rs b/ntex-service/src/pipeline.rs
index b9154bb6..5b3d3248 100644
--- a/ntex-service/src/pipeline.rs
+++ b/ntex-service/src/pipeline.rs
@@ -105,7 +105,7 @@ impl<T: Service<R>, R> Pipeline<T, R> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>, R>
+    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, R, F, E>, R>
     where
         Self: Sized,
         F: Fn(T::Error) -> E,
@@ -158,7 +158,10 @@ pub struct PipelineFactory<T, R, C = ()> {
 
 impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
     /// Call another service after call to this one has resolved successfully.
-    pub fn and_then<F, U>(self, factory: F) -> PipelineFactory<AndThenFactory<T, U>, R, C>
+    pub fn and_then<F, U>(
+        self,
+        factory: F,
+    ) -> PipelineFactory<AndThenFactory<T, U, R, C>, R, C>
     where
         Self: Sized,
         C: Clone,
@@ -228,7 +231,7 @@ impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
     pub fn map_err<F, E>(
         self,
         f: F,
-    ) -> PipelineFactory<MapErrServiceFactory<T, C, F, E>, R, C>
+    ) -> PipelineFactory<MapErrServiceFactory<T, R, C, F, E>, R, C>
     where
         Self: Sized,
         F: Fn(T::Error) -> E + Clone,
@@ -240,7 +243,10 @@ impl<T: ServiceFactory<R, C>, R, C> PipelineFactory<T, R, C> {
     }
 
     /// Map this factory's init error to a different error, returning a new service.
-    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, E>, R, C>
+    pub fn map_init_err<F, E>(
+        self,
+        f: F,
+    ) -> PipelineFactory<MapInitErr<T, R, C, F, E>, R, C>
     where
         Self: Sized,
         F: Fn(T::InitError) -> E + Clone,