Question: ```
scala> def a(i:Int)(j:Int) = i * j
a: (i: Int)(j: Int)Int

scala> def b(i:Int, j:Int) = i * j
b: (i: Int, j: Int)Int

```

The two definitions are very similar, and they (appear to me) do the same thing.

Apart from defining a function which receives implicit parameters or a code block as parameter, is there any reason to use the first definition style?

Answer: 
The main reason for "currying" functions in this manner is to enable partial application:

```
scala> val c = a(5) _
c: Int => Int = <function1>

```

Here c is a function that takes a single int and returns the result of multiplying that int with 5. It may be that you would set up c in one method, and pass it into another method that expects a function taking one Int parameter. A bit trivial in this case, but very flexible for a range of uses.
Additional to support currying, it also helps with type inference: Sometimes the compiler can't infer the correct type if everything is in one argument list, but if you split off the part that depends on the binding of the other arguments, it works. A typical example is `foldLeft`: Try to implement it with one argument list, and then in some cases the compiler needs type annotations.