Suspend run for all Http aliases

Author: rossabaker

core/src/main/scala/org/http4s/Http.scala

@@ -2,18 +2,21 @@ package org.http4s
 
 import cats.Applicative
 import cats.data.Kleisli
+import cats.effect.Sync
 
 /** Functions for creating [[Http]] kleislis. */
 object Http {
-  /** Lifts a function into an [[Http]] kleisli. 
+  /** Lifts a function into an [[Http]] kleisli.  The application of
+    * `run` is suspended in `F` to permit more efficient combination
+    * of routes via `SemigroupK`.
     * 
     * @tparam F the effect of the [[Response]] returned by the [[Http]]
     * @tparam G the effect of the bodies of the [[Request]] and [[Response]]
     * @param run the function to lift
-    * @return an [[Http]] that wraps `run`
+    * @return an [[Http]] that suspends `run`.
     */
-  def apply[F[_], G[_]](run: Request[G] => F[Response[G]]): Http[F, G] =
-    Kleisli(run)
+  def apply[F[_], G[_]](run: Request[G] => F[Response[G]])(implicit F: Sync[F]): Http[F, G] =
+    Kleisli(req => F.suspend(run(req)))
 
   /** Lifts an effectful [[Response]] into an [[Http]] kleisli. 
     * 
@@ -35,7 +38,9 @@ object Http {
   def pure[F[_]: Applicative, G[_]](r: Response[G]): Http[F, G] =
     Kleisli.pure(r)
 
-  /** Transforms an [[Http]] on its input.
+  /** Transforms an [[Http]] on its input.  The application of the
+    * transformed function is suspended in `F` to permit more
+    * efficient combination of routes via `SemigroupK`.
     * 
     * @tparam F the effect of the [[Response]] returned by the [[Http]]
     * @tparam G the effect of the bodies of the [[Request]] and [[Response]]
@@ -44,6 +49,6 @@ object Http {
     * @return An [[Http]] whose input is transformed by `f` before
     * being applied to `fa`
     */
-  def local[F[_], G[_]](f: Request[G] => Request[G])(fa: Http[F, G]): Http[F, G] =
-    Kleisli.local(f)(fa)
+  def local[F[_], G[_]](f: Request[G] => Request[G])(fa: Http[F, G])(implicit F: Sync[F]): Http[F, G] =
+    Kleisli(req => F.suspend(fa.run(f(req))))
 }

core/src/main/scala/org/http4s/HttpApp.scala

@@ -2,17 +2,20 @@ package org.http4s
 
 import cats.Applicative
 import cats.data.Kleisli
+import cats.effect.Sync
 
-/** Functions for creating [[HttpApp]]s. */
+/** Functions for creating [[HttpApp]] kleislis. */
 object HttpApp {
-  /** Lifts a function into an [[HttpApp]]. 
+  /** Lifts a function into an [[HttpApp]].  The application of `run` is
+    * suspended in `F` to permit more efficient combination of routes
+    * via `SemigroupK`.
     * 
     * @tparam F the effect of the [[HttpApp]].
     * @param run the function to lift
     * @return an [[HttpApp]] that wraps `run`
     */
-  def apply[F[_]](run: Request[F] => F[Response[F]]): HttpApp[F] =
-    Kleisli(run)
+  def apply[F[_]: Sync](run: Request[F] => F[Response[F]]): HttpApp[F] =
+    Http(run)
 
   /** Lifts an effectful [[Response]] into an [[HttpApp]]. 
     * 
@@ -32,14 +35,16 @@ object HttpApp {
   def pure[F[_]: Applicative](r: Response[F]): HttpApp[F] =
     Kleisli.pure(r)
 
-  /** Transforms an [[HttpApp]] on its input.
+  /** Transforms an [[HttpApp]] on its input.  The application of the
+    * transformed function is suspended in `F` to permit more
+    * efficient combination of routes via `SemigroupK`.
     * 
     * @tparam F the effect of the [[HttpApp]]
     * @param f a function to apply to the [[Request]]
     * @param fa the [[HttpApp]] to transform
     * @return An [[HttpApp]] whose input is transformed by `f` before
     * being applied to `fa`
     */
-  def local[F[_]](f: Request[F] => Request[F])(fa: HttpApp[F]): HttpApp[F] =
-    Kleisli.local[F, Response[F], Request[F]](f)(fa)
+  def local[F[_]](f: Request[F] => Request[F])(fa: HttpApp[F])(implicit F: Sync[F]): HttpApp[F] =
+    Http.local(f)(fa)
 }

core/src/main/scala/org/http4s/HttpRoutes.scala

@@ -5,18 +5,20 @@ import cats.data.{Kleisli, OptionT}
 import cats.effect.Sync
 import cats.implicits._
 
-/** Functions for creating [[HttpRoutes]]. */
+/** Functions for creating [[HttpRoutes]] kleislis. */
 object HttpRoutes {
-  /** Lifts a function into [[HttpRoutes]].
+  /** Lifts a function into an [[HttpRoutes]].  The application of `run`
+    * is suspended in `F` to permit more efficient combination of
+    * routes via `SemigroupK`.
     * 
     * @tparam F the effect of the [[HttpRoutes]]
     * @param run the function to lift
     * @return an [[HttpRoutes]] that wraps `run`
     */
-  def apply[F[_]](run: Request[F] => OptionT[F, Response[F]]): HttpRoutes[F] =
-    Kleisli(run)
+  def apply[F[_]: Sync](run: Request[F] => OptionT[F, Response[F]]): HttpRoutes[F] =
+    Http(run)
 
-  /** Lifts an effectful [[Response]] into [[HttpRoutes]]. 
+  /** Lifts an effectful [[Response]] into an [[HttpRoutes]]. 
     * 
     * @tparam F the effect of the [[HttpRoutes]]
     * @param fr the effectful [[Response]] to lift
@@ -25,7 +27,7 @@ object HttpRoutes {
   def liftF[F[_]](fr: OptionT[F, Response[F]]): HttpRoutes[F] =
     Kleisli.liftF(fr)
 
-  /** Lifts a [[Response]] into [[HttpRoutes]]. 
+  /** Lifts a [[Response]] into an [[HttpRoutes]]. 
     * 
     * @tparam F the base effect of the [[HttpRoutes]]
     * @param r the [[Response]] to lift
@@ -34,28 +36,30 @@ object HttpRoutes {
   def pure[F[_]](r: Response[F])(implicit FO: Applicative[OptionT[F, ?]]): HttpRoutes[F] =
     Kleisli.pure(r)
 
-  /** Transforms [[HttpRoutes]] on its input.
+  /** Transforms an [[HttpRoutes]] on its input.  The application of the
+    * transformed function is suspended in `F` to permit more
+    * efficient combination of routes via `SemigroupK`.
     * 
     * @tparam F the base effect of the [[HttpRoutes]]
     * @param f a function to apply to the [[Request]]
     * @param fa the [[HttpRoutes]] to transform
-    * @return [[HttpRoutes]] whose input is transformed by `f` before
+    * @return An [[HttpRoutes]] whose input is transformed by `f` before
     * being applied to `fa`
     */
-  def local[F[_]](f: Request[F] => Request[F])(fa: HttpRoutes[F]): HttpRoutes[F] =
-    Kleisli.local[OptionT[F, ?], Response[F], Request[F]](f)(fa)
+  def local[F[_]: Sync](f: Request[F] => Request[F])(fa: HttpRoutes[F]): HttpRoutes[F] =
+    Http.local[OptionT[F, ?], F](f)(fa)
 
   /** Lifts a partial function into an [[HttpRoutes]].  The application of the
-    * partial function is delayed in `F` to permit more efficient combination
+    * partial function is suspended in `F` to permit more efficient combination
     * of routes via `SemigroupK`.
     * 
     * @tparam F the base effect of the [[HttpRoutes]]
-    * @param pfthe partial function to lift
-    * @return [[HttpRoutes]] that returns some [[Response]] in an `OptionT[F, ?]`
+    * @param pf the partial function to lift
+    * @return An [[HttpRoutes]] that returns some [[Response]] in an `OptionT[F, ?]`
     * wherever `pf` is defined, an `OptionT.none` wherever it is not
     */
   def of[F[_]](pf: PartialFunction[Request[F], F[Response[F]]])(implicit F: Sync[F]): HttpRoutes[F] =
-    Kleisli(req => OptionT(F.delay(pf.lift(req).sequence).flatten))
+    Kleisli(req => OptionT(F.suspend(pf.lift(req).sequence)))
 
   /** An empty set of routes.  Always responds with `pOptionT.none`.
     *