Scala/Function literals

It often occurs that a function is defined only to be used once. Since it is only defined once, it is somewhat superfluous to give it a name. To avoid repeatedly naming and using functions once, there exists a facility to just avoid naming them at all. These are called anonymous functions or function literals. A simple example of a function turned into an anonymous version:

The two functions above are effectively the same, except that the second one does not have a name. But the above example is not very exciting. So let's see it in action by applying using it in a higher-order function:

Quite a bit shorter, since we previously had to write "isEqualToFour" twice, and use a "def". But it can be shorter. Since the function literal is used inside a function, the Scala compiler can infer the argument types:

Much better. But the "a" is basically a throw-away name. When using a function literal inside a higher-order function, instead of defining the arguments, you can just write an expression that uses "_" for the arguments:

This version is about as concise as it gets. The rules for using "_" is that the first-time use of "_" refers to the first argument, the second-time use of "_" refers to the second argument, and so on. So the following example won't work, since the function literal is expected to take just one argument, but the use of "_" twice means that the function literal has two arguments: