Why does the following Play syntax work
def handleForm = Action(parse.tolerantFormUrlEncoded) { implicit request =>
val username = request.body.get("username").map(_.head).getOrElse("");
Ok("Username was " + username)
}
Without specifying the type of request, how would the compiler know how to resolve the implicit?
An Action in Play can be seen as a function: Request[A] => Result. Internally an Action is defined like trait Action[A] extends EssentialAction
The type A is actually the one which allows you to put anything in there. As you can see from the code, the Request is defined like this: trait Request[+A] extends RequestHeader. Interesting here is also the plus sign (+). It is the so-called covariant annotation. This covariant type parameter is one which is allowed to vary down as the class is subtyped. It means that if you have something like
trait List[+A]
then List[Int] is a subtype of List[AnyVal] because Int is a subtype of AnyVal. This means that you may provide an instance of List[Int] when a value of type List[AnyVal] is expected.
All this allows you to have a super generic request which serves as a base for your action and therefore no compile time troubles should be expected.
And something as for why is this all necessary from a more user-related point of view:
From the Play Scala documentation:
It is often useful to mark the request parameter as implicit so it can be implicitly used by other APIs that need it:
Action { implicit request => Ok("Got request [" + request + "]") }
It doesn't actually resolve the implicit, you mark the parameter as implicit, for further method calls inside the request handler. Whenever you call a method which accepts an implicit Request parameter, the request argument from the request handler will be automatically passed to it. If you wouldn't mark the request argument as implicit, you'd have to explicitly pass the request argument for each method call who needs an implicit request parameter.
update: upon your comment I updated your code with type parameters to clarify. So even when you use different BodyParsers, your request parameter is still going to be of Request type, so there is no need to convert it, it's just going to be parametrized differently based on your body parser. request.body is going to have the same type as the type parameter, Map[String, Seq[String]] in this example. If you use a JSON body parser then your request parameter would be a Request[JsValue], and the request.body is a JsValue.
def handleForm: Action[Map[String, Seq[String]]] = Action(parse.tolerantFormUrlEncoded)({
implicit request: Request[Map[String, Seq[String]]] =>
val username = request.body.get("username").map(_.head).getOrElse("")
Ok("Username was " + username)
})
tl;dr You can just do Action(...) { request => ... } if you don't need an implicit Request for further method calls inside the request handler
handleForm simply accepts an implicit parameter called request for which the naming is arbitrary?
parse.tolerantFormUrlEncoded to request type right? Since parse.tolerantFormUrlEncoded.body returns an error.parse.tolerantFormUrlEncoded.body returns an error, because parse.tolerantFormUrlEncoded is a body parser, not a Request. But request.body is going to be the right type, corresponding to your type parser