Currying Scala functions

One 、 Definition

         It transforms a function that accepts multiple parameters into a function that accepts a single parameter ( First parameter of the original function ) Function of , And return the technique of taking the remaining arguments and returning the result of the new function .

         A simple understanding is to change the expression of a function, but its functional characteristics remain unchanged , Coriolism is actually very practical . Whether it is in improving applicability or in delaying execution or fixing volatile factors , Coritization technology plays an important role .

Two 、 example

First we define a function :

def add(x:Int,y:Int)=x+y

So when we apply , It should be used like this ：add(1,2)

Now let's shape this function ：

def add(x:Int)(y:Int) = x + y

So when we apply , It should be used like this ：add(1)(2), The end result is the same 3, This way, （ The process ） It's called Coriolis .

3、 ... and 、 Implementation process

add(1)(2) It's actually calling two ordinary functions in turn （ Non Coriolis function ）, The first call uses a parameter x, Returns the value of a function type , The second use of parameters y Call the value of this function type .

In essence, it first evolved into such a method ：

def add(x:Int)=(y:Int)=>x+y

So what does this function mean ？ Receive one x Is the parameter , Returns an anonymous function , The anonymous function is defined as ： Receive one Int Type parameter y, Function body is x+y. Call this method now .

val result = add(1) 

Return to one result, that result The value of should be an anonymous function ：(y:Int)=>1+y

So in order to get the results , We continue to call result.

val sum = result(2)

The final printed result is 3.

Four 、 Complete example

object _02FuncDemo {
  // Define a method （ currying ）, Calculate two Int Type value 
  def calculate(a:Int, b:Int)(calc:(Int, Int) => Int) ={
    calc(a, b)
  }

  def main(args: Array[String]): Unit = {
    println(calculate(10, 10) {
      (x, y) => x + y
    })
    println(calculate(1,2)(_ + _))
    println(calculate(1,2)(_ * _))
    println(calculate(1,2)(_ - _))
  }
}

Output results ：

20
3
2
-1