What does this piece of code mean in scala?

Question

def func(arg: String => Int): Unit = {
    // body of function
}

I mean this fragment: String => Int

Answer 1

Short answer

Its a function that receives a String and returns a Int

Long answer

In Scala, functions are first class citizens. That means you can store them in variables or (like in this case) pass them around as arguments.

This is how a function literal looks like

() => Unit

This is a function that receives no arguments and returns Unit (java's equivalent to void).

This would be a function that receives a String as a parameter and returns an Int:

(String) => Int

Also, scala let's you drop the parenthesis as a form of syntactic sugar, like in your example. The preceding arg: is just the name of the argument.

Inside func you would call the function received (arg) like this:

val result = arg("Some String") // this returns a Int

Answer 2

As mentioned in Advantages of Scala’s Type System, it is a Functional type.

The article Scala for Java Refugees Part 6: Getting Over Java describes this syntax in its section "Higher-Order Functions".

def itrate(array:Array[String], fun:(String)=>Unit) = {
  for (i <- 0 to (array.length - 1)) {    // anti-idiom array iteration
    fun(array(i))
  }
}

val a = Array("Daniel", "Chris", "Joseph", "Renee")
iterate(a, (s:String) => println(s))

See? The syntax is so natural you almost miss it.
Starting at the top, we look at the type of the fun parameter and we see the (type1, …)=>returnType syntax which indicates a functional type.
In this case, fun will be a functional which takes a single parameter of type String and returns Unit (effectively void, so anything at all).
Two lines down in the function, we see the syntax for actually invoking the functional. fun is treated just as if it were a method available within the scope, the call syntax is identical.
Veterans of the C/C++ dark-ages will recognize this syntax as being reminiscent of how function pointers were handled back-in-the-day.
The difference is, no memory leaks to worry about, and no over-verbosity introduced by too many star symbols.

---

In your case: def func(arg: String => Int): Unit, arg would be a function taking a String and returning an Int.

Answer 3

You might also see it written (perhaps by a decompiler) as

def func(arg: Function1[String, Int]): Unit = {
    // body of function
}

They are precisely equivalent.