What's the meaning of: 'request => out => ' in Play Framework - scala

Question

While I was diving in the Play Framework 2 reference documentation, I foun this syntax regarding WebSockets:
def socket = WebSocket.acceptWithActor[String, String] { request => out =>
MyWebSocketActor.props(out)
}
https://www.playframework.com/documentation/2.3.x/ScalaWebSockets
But I'm not able to understand the "meaning" of this syntax 'request => out'. I can infer that from a WebSocket request, I get an ActorRef called out, but I'm asking if anyone can make me see the match with this syntax and the method signature found in their API.
I've used Akka+Scala to develop a small application so I know some scala basic syntax.
Solved
See both Angelo Genovese and bjfletcher answers.

Answer 1

request ⇒ out ⇒ MyWebSocketActor.props(out)
Is a function which takes a RequestHeader and returns a function which takes an ActorRef and returns a Props
in the API you linked this is represented as
f: (RequestHeader) ⇒ (ActorRef) ⇒ Props
it might be easier to visualize this way:
def first(request: RequestHeader) = {
def second (out: ActorRef) = {
MyWebSocketActor.props(out)
}
second _
}

Answer 2

Looking at the definition for acceptWithActor:
def acceptWithActor(f: RequestHeader => HandlerProps)
you see that it takes in a parameter that is a function, which takes in a RequestHeader object and produces a HandlerProps object.
Your goal therefore is to put together a function that takes RequestHeader:
request => { ... produce HandlerProps here ... }
now, you need to return a HandlerProps object, let's have a look at what this is:
type HandlerProps = ActorRef => Props
so, your next goal is to take in an ActorRef object and produce a Props:
request => {
actorRef => {
... produce Props here ...
}
}
now, you need to produce a Props object:
MyWebSocketActor.props(out)
Putting it all together, you have your code there. Play uses the convention of naming the actor reference as out not actorRef.
I hope this helps.
Update (see comments)
You can indeed specify the types:
....acceptWithActor[String, String] { request: RequestHeader => out: ActorRef => ...
which sometimes can read better than without. They're not necessary because they're indeed inferred by the compiler which looks at all this in the same way as I explained above.