Add `Router.Result#map` to DRY up repetitive pattern matches

3 files changed, 38 insertions, 40 deletions

diff --git a/cask/src/cask/decorators/compress.scala b/cask/src/cask/decorators/compress.scala
index fc67dd4..22bd29e 100644
--- a/cask/src/cask/decorators/compress.scala
+++ b/cask/src/cask/decorators/compress.scala
@@ -9,35 +9,32 @@ import collection.JavaConverters._
 class compress extends cask.Decorator{
   def wrapFunction(ctx: ParamContext, delegate: Delegate) = {
     val acceptEncodings = ctx.exchange.getRequestHeaders.get("Accept-Encoding").asScala.flatMap(_.split(", "))
-    delegate(Map()) match{
-      case Router.Result.Success(v) =>
-        val (newData, newHeaders) = if (acceptEncodings.exists(_.toLowerCase == "gzip")) {
-          new Response.Data {
-            def write(out: OutputStream): Unit = {
-              val wrap = new GZIPOutputStream(out)
-              v.data.write(wrap)
-              wrap.flush()
-              wrap.close()
-            }
-          } -> Seq("Content-Encoding" -> "gzip")
-        }else if (acceptEncodings.exists(_.toLowerCase == "deflate")){
-          new Response.Data {
-            def write(out: OutputStream): Unit = {
-              val wrap = new DeflaterOutputStream(out)
-              v.data.write(wrap)
-              wrap.flush()
-            }
-          } -> Seq("Content-Encoding" -> "deflate")
-        }else v.data -> Nil
-        Router.Result.Success(
-          Response(
-            newData,
-            v.statusCode,
-            v.headers ++ newHeaders,
-            v.cookies
-          )
-        )
-      case e: Router.Result.Error => e
+    delegate(Map()).map{ v =>
+      val (newData, newHeaders) = if (acceptEncodings.exists(_.toLowerCase == "gzip")) {
+        new Response.Data {
+          def write(out: OutputStream): Unit = {
+            val wrap = new GZIPOutputStream(out)
+            v.data.write(wrap)
+            wrap.flush()
+            wrap.close()
+          }
+        } -> Seq("Content-Encoding" -> "gzip")
+      }else if (acceptEncodings.exists(_.toLowerCase == "deflate")){
+        new Response.Data {
+          def write(out: OutputStream): Unit = {
+            val wrap = new DeflaterOutputStream(out)
+            v.data.write(wrap)
+            wrap.flush()
+          }
+        } -> Seq("Content-Encoding" -> "deflate")
+      }else v.data -> Nil
+      Response(
+        newData,
+        v.statusCode,
+        v.headers ++ newHeaders,
+        v.cookies
+      )
     }
+
   }
 }
diff --git a/cask/src/cask/endpoints/StaticEndpoints.scala b/cask/src/cask/endpoints/StaticEndpoints.scala
index 048f89a..e93c09b 100644
--- a/cask/src/cask/endpoints/StaticEndpoints.scala
+++ b/cask/src/cask/endpoints/StaticEndpoints.scala
@@ -11,10 +11,7 @@ class static(val path: String) extends Endpoint {
   type InputParser[T] = QueryParamReader[T]
   override def subpath = true
   def wrapFunction(ctx: ParamContext, delegate: Delegate): Returned = {
-    delegate(Map()) match{
-      case Router.Result.Success(t) => Router.Result.Success(cask.model.Static(t + "/" + ctx.remaining.mkString("/")))
-      case e: Router.Result.Error => e
-    }
+    delegate(Map()).map(t => cask.model.Static(t + "/" + ctx.remaining.mkString("/")))
   }
 
   def wrapPathSegment(s: String): Input = Seq(s)
diff --git a/cask/src/cask/internal/Router.scala b/cask/src/cask/internal/Router.scala
index c66e8d2..36976af 100644
--- a/cask/src/cask/internal/Router.scala
+++ b/cask/src/cask/internal/Router.scala
@@ -75,19 +75,25 @@ object Router{
     * Represents what comes out of an attempt to invoke an [[EntryPoint]].
     * Could succeed with a value, but could fail in many different ways.
     */
-  sealed trait Result[+T]
+  sealed trait Result[+T]{
+    def map[V](f: T => V): Result[V]
+  }
   object Result{
 
     /**
       * Invoking the [[EntryPoint]] was totally successful, and returned a
       * result
       */
-    case class Success[T](value: T) extends Result[T]
+    case class Success[T](value: T) extends Result[T]{
+      def map[V](f: T => V) = Success(f(value))
+    }
 
     /**
       * Invoking the [[EntryPoint]] was not successful
       */
-    sealed trait Error extends Result[Nothing]
+    sealed trait Error extends Result[Nothing]{
+      def map[V](f: Nothing => V) = this
+    }
 
 
     object Error{
@@ -316,10 +322,8 @@ class Router[C <: Context](val c: C) {
         $argValuesSymbol: Seq[Map[String, Any]],
         $argSigsSymbol: scala.Seq[scala.Seq[cask.internal.Router.ArgSig[Any, _, _, $ctx]]]
       ) =>
-        cask.internal.Router.validate(Seq(..${readArgs.flatten.toList})) match{
-          case cask.internal.Router.Result.Success(Seq(..${argNames.flatten.toList})) =>
-            cask.internal.Router.Result.Success($convertToResultType($methodCall))
-          case x: cask.internal.Router.Result.Error => x
+        cask.internal.Router.validate(Seq(..${readArgs.flatten.toList})).map{
+          case Seq(..${argNames.flatten.toList}) => $convertToResultType($methodCall)
         }
     )
     """