Akka-HTTP compilation error using custom requireParam() directive

Question

I developed custom generic directive, which will provide param of given type, if it exists, or else reject with my custom exception.

import akka.http.scaladsl.common.NameReceptacle
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server.directives.ParameterDirectives.ParamDefAux
import akka.http.scaladsl.server.{Directive1, Route}

class MyCustomException(msg: String) extends Exception(msg)

def requireParam[T](name: NameReceptacle[T])
                   (implicit pdef: ParamDefAux[NameReceptacle[T], Directive1[T]]): Directive1[T] =
  parameter(name).recover { _ =>
    throw new MyCustomException(s"${name.name} is missed!")
  }

It works ok, if I want to create route, using two parameters, for example:

val negSumParams: Route =
  (requireParam("param1".as[Int]) & requireParam("param2".as[Int])) {
    (param1, param2) =>
      complete((-param1-param2).toString)
  }

But if I try to use exactly one parameter, this doesn't compile:

val negParamCompilationFail: Route =
  requireParam("param".as[Int]) {
    param => // scalac complains about missing type param here
      complete((-param).toString)
  }

If I use it with pass directive, it works:

val negParamWithPass: Route =
  (pass & requireParam("param".as[Int])) { // this pass usage looks hacky
    param =>
      complete((-param).toString)
  }

If I write requireParam() return type explicitly, it works too:

val negParamWithExplicitType: Route =
  (requireParam("param".as[Int]): Directive1[Int]) { // DRY violation
    param =>
      complete((-param).toString)
  }

Why do I need these tricks? Why can't it work just with requireParam("param".as[Int])?

Scala version 2.12.1, Akka-HTTP 10.0.10.

Emiliano Martinez Emiliano Martinez · Accepted Answer · 2017-11-13T17:52:24

This error happens due to the Directive companion object apply method. IT allows to create a Route from a function with parameter (T => Route) => Route:

object Directive {

  /**
   * Constructs a directive from a function literal.
   */
  def apply[T: Tuple](f: (T ⇒ Route) ⇒ Route): Directive[T] =
    new Directive[T] { def tapply(inner: T ⇒ Route) = f(inner) }

}

But the T parameter must be a tuple. In your case, the compiler can not build the Route. Your requireParam("param".as[Int]) returns a Directive1[Int] so the apply method doesn´t work because Int is not a Tuple.

To make this work you shoul use tapply method directly:

(requireParam("param1".as[Int])).tapply((param1) =>
    complete((-param1._1).toString))

and

  val negSumParams2: Route =
    (requireParam("param1".as[Int]) & requireParam("param2".as[Int])).tapply {
      case (param1, param2) =>
        complete((-param1-param2).toString)
    }

So it seems that every Directive tries to convert its param to TupleX. For example:

path("order" / IntNumber) returns a Directive[Tuple1[Int]] instead of Directive1[Int]. In your case requireParam("param1".as[Int]) returns Directive1[Int]

Maybe there is a better solution and to avoid tapply

Akka-HTTP compilation error using custom requireParam() directive

2 Answers