use From/Into instead of custom IntoService and IntoNewService traits

src/lib.rs

@@ -63,7 +63,7 @@ mod worker;
 
 pub use configurable::{IntoNewConfigurableService, NewConfigurableService};
 pub use server::Server;
-pub use service::{IntoNewService, IntoService, NewServiceExt, ServiceExt};
+pub use service::{NewServiceExt, ServiceExt};
 
 /// Pause accepting incoming connections
 ///

src/service/and_then.rs

@@ -4,8 +4,6 @@ use std::rc::Rc;
 use futures::{Async, Future, Poll};
 use tower_service::{NewService, Service};
 
-use super::IntoNewService;
-
 /// `AndThen` service combinator
 pub struct AndThen<A, B> {
     a: A,
@@ -114,11 +112,8 @@ where
     B: NewService,
 {
     /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self {
+    pub fn new<F: Into<B>>(a: A, f: F) -> Self {
-        Self {
+        Self { a, b: f.into() }
-            a,
-            b: f.into_new_service(),
-        }
     }
 }
 

src/service/apply.rs

@@ -1,7 +1,8 @@
 use std::marker::PhantomData;
 
 use futures::{Async, Future, IntoFuture, Poll};
-use {IntoNewService, NewService, Service};
+
+use {NewService, Service};
 
 /// `Apply` service combinator
 pub struct Apply<T, F, R, Req> {
@@ -62,10 +63,10 @@ where
     R: IntoFuture,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T>>(f: F, service: F1) -> Self {
+    pub fn new<F1: Into<T>>(f: F, service: F1) -> Self {
         Self {
             f,
-            service: service.into_new_service(),
+            service: service.into(),
             r: PhantomData,
         }
     }

src/service/fn_service.rs

@@ -6,8 +6,6 @@ use futures::{
 };
 use tower_service::{NewService, Service};
 
-use super::IntoNewService;
-
 pub struct FnService<F, Req, Resp, E, Fut>
 where
     F: Fn(Req) -> Fut,
@@ -113,14 +111,13 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, IErr, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, IErr, Fut>>
+impl<F, Req, Resp, Err, IErr, Fut> From<F> for FnNewService<F, Req, Resp, Err, IErr, Fut>
-    for F
 where
     F: Fn(Req) -> Fut + Clone + 'static,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
-    fn into_new_service(self) -> FnNewService<F, Req, Resp, Err, IErr, Fut> {
+    fn from(f: F) -> FnNewService<F, Req, Resp, Err, IErr, Fut> {
-        FnNewService::new(self)
+        FnNewService::new(f)
     }
 }
 

src/service/fn_state_service.rs

@@ -3,8 +3,6 @@ use std::marker;
 use futures::{Async, Future, IntoFuture, Poll};
 use tower_service::{NewService, Service};
 
-use super::IntoNewService;
-
 pub struct FnStateService<S, F, Req, Resp, Err, Fut>
 where
     F: Fn(&mut S, Req) -> Fut,
@@ -113,8 +111,8 @@ where
     }
 }
 
-impl<S, F1, F2, Req, Resp, Err1, Err2, Fut1, Fut2>
+impl<S, F1, F2, Req, Resp, Err1, Err2, Fut1, Fut2> From<(F1, F2)>
-    IntoNewService<FnStateNewService<S, F1, F2, Req, Resp, Err1, Err2, Fut1, Fut2>> for (F1, F2)
+    for FnStateNewService<S, F1, F2, Req, Resp, Err1, Err2, Fut1, Fut2>
 where
     S: 'static,
     F1: Fn(&mut S, Req) -> Fut1 + Clone + 'static,
@@ -126,10 +124,8 @@ where
     Err1: 'static,
     Err2: 'static,
 {
-    fn into_new_service(
+    fn from(data: (F1, F2)) -> FnStateNewService<S, F1, F2, Req, Resp, Err1, Err2, Fut1, Fut2> {
-        self,
+        FnStateNewService::new(data.0, data.1)
-    ) -> FnStateNewService<S, F1, F2, Req, Resp, Err1, Err2, Fut1, Fut2> {
-        FnStateNewService::new(self.0, self.1)
     }
 }
 

src/service/mod.rs

@@ -33,10 +33,10 @@ pub trait ServiceExt: Service {
     fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
     where
         Self: Sized,
-        F: IntoService<B>,
+        F: Into<B>,
         B: Service<Request = Self::Response, Error = Self::Error>,
     {
-        AndThen::new(self, service.into_service())
+        AndThen::new(self, service.into())
     }
 
     fn map<F, R>(self, f: F) -> Map<Self, F, R>
@@ -70,7 +70,7 @@ pub trait NewServiceExt: NewService {
     fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
     where
         Self: Sized,
-        F: IntoNewService<B>,
+        F: Into<B>,
         B: NewService<
             Request = Self::Response,
             Error = Self::Error,
@@ -113,51 +113,15 @@ pub trait NewServiceExt: NewService {
     }
 }
 
-impl<T: Service> ServiceExt for T {}
+impl<T: ?Sized> ServiceExt for T where T: Service {}
-impl<T: NewService> NewServiceExt for T {}
+impl<T: ?Sized> NewServiceExt for T where T: NewService {}
 
-/// Trait for types that can be converted to a Service
+impl<F, Req, Resp, Err, Fut> From<F> for FnService<F, Req, Resp, Err, Fut>
-pub trait IntoService<T>
-where
-    T: Service,
-{
-    /// Create service
-    fn into_service(self) -> T;
-}
-
-/// Trait for types that can be converted to a Service
-pub trait IntoNewService<T>
-where
-    T: NewService,
-{
-    /// Create service
-    fn into_new_service(self) -> T;
-}
-
-impl<T> IntoService<T> for T
-where
-    T: Service,
-{
-    fn into_service(self) -> T {
-        self
-    }
-}
-
-impl<T> IntoNewService<T> for T
-where
-    T: NewService,
-{
-    fn into_new_service(self) -> T {
-        self
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F
 where
     F: Fn(Req) -> Fut + 'static,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
-    fn into_service(self) -> FnService<F, Req, Resp, Err, Fut> {
+    fn from(f: F) -> FnService<F, Req, Resp, Err, Fut> {
-        FnService::new(self)
+        FnService::new(f)
     }
 }

src/stream.rs

@@ -2,7 +2,7 @@ use futures::unsync::mpsc;
 use futures::{Async, Future, Poll, Stream};
 use tokio::executor::current_thread::spawn;
 
-use super::{IntoService, Service};
+use super::Service;
 
 pub struct StreamDispatcher<S: Stream, T> {
     stream: S,
@@ -18,12 +18,12 @@ where
     T: Service<Request = 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: Into<T>>(stream: S, service: F) -> Self {
         let (stop_tx, stop_rx) = mpsc::unbounded();
         StreamDispatcher {
             stream,
             item: None,
-            service: service.into_service(),
+            service: service.into(),
             stop_rx,
             stop_tx,
         }