We can inspect the type of the applyTwo function using REPL:

scala> :type Functions.applyTwo
(Int, Long) => Unit

This is what the type of a first-class function looks like! In general, the type of function has right and left parts separated by the =>. The left part defines the types of the arguments, the right part—the type of the result. The implementation follows the same pattern and is called function literal. Here is an example of the full definition for a function of four arguments:

val hash: (Int, Boolean, String, Long) => Int = (a, b, c, d) => {
  val ab = 31 * a.hashCode() + b.hashCode()
  val abc = 31 * ab + c.hashCode
  31 * abc + d.hashCode()
}

On the implementation side, we have a code block which consists of three expressions and therefore is wrapped in curly braces. Please note that we define our function as a val. 

Usually, the function literal can be defined using simplified syntax. For instance, the type inference allows leaving the definition of the result type. The type definition, in this case, disappears altogether, because the type definitions for the parameters will move close to the parameter names exactly as in the definition of a method:

val hashInferred = (a: Int, b: Boolean, c: String, d: Long) =>
  // ... same implementation as before

On the application side, the compiler can help us to simplify the definition even more. Let's consider an example:

def printHash(hasher: String => Int)(s: String): Unit = 
  println(hasher(s))

We could have the following equal definitions for the hasher function. The full definition looks like the next code block:

val hasher1: String => Int = s => s.hashCode
val hasher2 = (s: String) => s.hashCode
printHash(hasher1)("Full")
printHash(hasher2)("Inferred result type")

This snippet illustrates four different ways to represent a function literal:

• Defined inline: printHash((s: String) => s.hashCode)("inline")
• Defined inline with type inference for the function parameter: printHash((s: String) => s.hashCode)("inline")
• Defined inline with type inference for the function parameter (this is known as target typing): printHash((s) => s.hashCode)("inline")
• The parentheses around single argument can be omitted: printHash(s => s.hashCode)("single argument parentheses")
• In the case, if an argument is used in the implementation of the function, at most once we can go further and use placeholder syntax: printHash(_.hashCode)("placeholder syntax")

In fact, the placeholder syntax is quite powerful and can also be used to define functions of multiple parameters as well as functions that are not in the target typing position. Here is an example of a function that calculates a hash code for four instances of  Int using the placeholder syntax:

scala> val hashPlaceholder = 
(_: Int) * 31^4 + (_: Int) * 31^3 + (_: Int) * 31^2 + (_: Int) * 31

scala> :type hashPlaceholder
(Int, Int, Int, Int) => Int

This syntax looks close to the partial application syntax, but represents a completely different language feature.