Functions in scala

Assuming f: Int => Int is a typo of val f: Int => Int,
and def f(Int => Int) is a typo of def f(i: Int): Int.

val f: Int => Int means that a value f is Function1[Int, Int].

First, A => B equals to =>[A, B].
This is just a shortcut writing, for example:

trait Foo[A, B]
val foo: Int Foo String // = Foo[Int, String]

Second, =>[A, B] equals to Function1[A, B].
This is called "type alias", defined like:

type ~>[A, B] = Foo[A, B]
val foo: Int ~> String // = Foo[Int, String]

def f(i: Int): Int is a method, not a function.
But a value g is Function1[Int, Int] where val g = f _ is defined.

f: Int => Int

means that type of f is Int => Int.

Now what does that mean? It means that f is a function which gets an Int and returns an Int.

You can define such a function with

def f(i: Int): Int = i * 2

or with

 def f: Int => Int = i => i * 2

or even with

def f: Int => Int = _ * 2

_ is a placeholder used for designating the argument. In this case the type of the parameter is already defined in Int => Int so compiler knows what is the type of this _.

The following is again equivalent to above definitions:

def f = (i:Int) => i * 2

In all cases type of f is Int => Int.

=>

So what is this arrow? If you see this arrow in type position (i.e. where a type is needed) it designates a function.

for example in

val func: String => String

But if you see this arrow in an anonymous function it separates the parameters from body of the function. For example in

i => i * 2

To elaborate just slightly on Nader's answer, f: Int => Int will frequently appear in a parameter list for a high order function, so

def myHighOrderFunction(f : Int => Int) : String = {
   // ...
   "Hi"
}

is a dumb high order function, but shows how you say that myOrderFunction takes as a parameter, f, which is a function that maps an int to an int.

So I might legally call it like this for example:

myHighOrderFunction(_ * 2)

A much more illustrative example comes from Odersky's Programming Scala:

object FileMatcher {
    private def filesHere = (new java.io.File(".")).listFiles
    private def filesMatching(matcher: String => Boolean) =
        for (file <- filesHere if matcher(file.getName))
            yield file
    def filesEnding(query: String) = filesMatching(_.endsWith(query))
    def filesContaining(query: String) = filesMatching(_.contains(query))
    def filesRegex(query: String) = filesMatching(_.matches(query))
}

Here filesMatching is a high order function, and we define three other functions that call it passing in different anonymous functions to do different kinds of matching.

Hope that helps.