add combinator for boxing ServiceFactory::Future (#118)

* add combinator for boxing ServiceFactory::Future

* fix lint

* fix typo

service/src/factory/boxed.rs

@@ -0,0 +1,32 @@
+use alloc::boxed::Box;
+
+use crate::BoxFuture;
+
+use super::ServiceFactory;
+
+pub struct BoxedServiceFactory<F> {
+    factory: F,
+}
+
+impl<F> BoxedServiceFactory<F> {
+    pub(super) fn new(factory: F) -> Self {
+        Self { factory }
+    }
+}
+
+impl<F, Req> ServiceFactory<Req> for BoxedServiceFactory<F>
+where
+    F: ServiceFactory<Req>,
+    F::Future: 'static,
+{
+    type Response = F::Response;
+    type Error = F::Error;
+    type Config = F::Config;
+    type Service = F::Service;
+    type InitError = F::InitError;
+    type Future = BoxFuture<'static, Self::Service, Self::InitError>;
+
+    fn new_service(&self, cfg: Self::Config) -> Self::Future {
+        Box::pin(self.factory.new_service(cfg))
+    }
+}

service/src/factory/ext.rs

@@ -5,6 +5,7 @@ use alloc::boxed::Box;
 use crate::transform::Transform;
 
 use super::{
+    boxed::BoxedServiceFactory,
     pipeline::{marker, PipelineServiceFactory},
     ServiceFactory, ServiceFactoryObject,
 };
@@ -34,6 +35,16 @@ pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
         PipelineServiceFactory::new(self, err)
     }
 
+    /// Box `<Self as ServiceFactory<_>>::Future` to reduce it's stack size.
+    ///
+    /// *. This combinator does not box `Self` or `Self::Service`.
+    fn boxed_future(self) -> BoxedServiceFactory<Self>
+    where
+        Self: Sized,
+    {
+        BoxedServiceFactory::new(self)
+    }
+
     /// Chain another service factory who's service takes `Self`'s `Service::Future` output as
     /// `Service::Request`.
     ///
@@ -48,6 +59,10 @@ pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
         PipelineServiceFactory::new(self, factory)
     }
 
+    /// Chain another service factory who's service takes `Self`'s `Service::Response` output as
+    /// `Service::Request`.
+    ///
+    /// *. Unlike `then` combinator both `F` and `Self`'s readiness are checked beforehand.
     fn and_then<F>(self, factory: F) -> PipelineServiceFactory<Self, F, marker::AndThen>
     where
         F: ServiceFactory<Self::Response>,
@@ -74,6 +89,11 @@ pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
         PipelineServiceFactory::new(self, transform)
     }
 
+    /// Box self and cast it to a trait object.
+    ///
+    /// This would erase `Self::Service` type and it's GAT nature.
+    ///
+    /// See [crate::service::ServiceObject] for detail.
     fn into_object(self) -> ServiceFactoryObject<Req, Self::Response, Self::Error, Self::Config, Self::InitError>
     where
         Self: Sized + 'static,

service/src/factory/mod.rs

@@ -1,6 +1,7 @@
 pub(crate) mod pipeline;
 
 mod and_then;
+mod boxed;
 mod ext;
 mod function;
 mod map;