scala 柯里化函数

// 定义变量
val a = 1
val b = 2

// 定义实际函数 add
def add(a: Int, b: Int): Int = {
  a + b
}

// 定义实际函数 multi
def multi(a: Int, b: Int): Int = {
  a * b
}

// 定义柯里化函数 f1
def f1(a: Int, b: Int)(g: (Int, Int) => Int): Int = {
  g(a, b)
}

// 定义柯里化函数 f2
def f2(a: Int, b: Int)(g: (Int, Int) => Int): Int = {
  System.out.println("------")
  g(a, b)
}

---

测试一

f1(a, b)(add)

// 输出
res0: Int = 3

分析：

1. 柯里化函数 f1 接收两组参数 (a: Int, b: Int) 和 (g: (Int, Int) => Int)
2. 首先执行 f1(a: Int, b: Int) 得到一个临时函数 temp，temp 函数接收一个函数作为参数

// temp 可定义为
def temp(g: (Int, Int) => Int): Int = {
  g(a, b)
}

3. 传入函数 add 到临时函数 temp，执行 add(a, b)

---

测试二

f2(a, b)(add)

// 输出
------
res1: Int = 3

分析：

1. 柯里化函数 f1 接收两组参数 (a: Int, b: Int) 和 (g: (Int, Int) => Int)
2. 首先执行 f1(a: Int, b: Int) 得到一个临时函数 temp，temp 函数接收一个函数作为参数

// temp 可定义为
def temp(g: (Int, Int) => Int): Int = {
  g(a, b)
}

3. 传入函数 add 到临时函数 temp，执行：

{
  System.out.println("------")
  g(a, b)
}

---

测试三

f1(a, b)(multi)

// 输出
res2: Int = 2

---

测试四

f1(a, b) {
  System.out.println("======")
  add
}

// 输出
======
res3: Int = 3

分析：

1. 柯里化函数 f1 接收两组参数 (a: Int, b: Int) 和 (g: (Int, Int) => Int)
2. 首先执行 f1(a: Int, b: Int) 得到一个临时函数 temp，temp 函数接收一个函数作为参数

// temp 可定义为
def temp(g: (Int, Int) => Int): Int = {
  g(a, b)
}

3. 接着执行下面内容，返回函数 add

{
  System.out.println("======")
  add
}

4. 传入函数 add 到临时函数 temp，执行 add(a, b)

---

测试五

f1(a, b) {
  System.out.println("======")
  add
  System.out.println("######")
}

// 输出
<console>:6: error: type mismatch;
 found   : Unit
 required: (Int, Int) => Int
       System.out.println("######")
                         ^

分析：

1. 柯里化函数 f1 接收两组参数 (a: Int, b: Int) 和 (g: (Int, Int) => Int)
2. 首先执行 f1(a: Int, b: Int) 得到一个临时函数 temp，temp 函数接收一个函数作为参数

// temp 可定义为
def temp(g: (Int, Int) => Int): Int = {
  g(a, b)
}

3. 接着执行下面内容，返回函数 System.out.println

{
  System.out.println("======")
  add
  System.out.println("######")
}

4. System.out.println 函数与 (Int, Int) => Int 类型不匹配，所以报错

因此，add 必须放在最后作为返回值。

---

测试六

f2(a, b) {
  System.out.println("======")
  add
}

// 输出
======
------
res5: Int = 3

分析：

1. 柯里化函数 f1 接收两组参数 (a: Int, b: Int) 和 (g: (Int, Int) => Int)
2. 首先执行 f1(a: Int, b: Int) 得到一个临时函数 temp，temp 函数接收一个函数作为参数

// temp 可定义为
def temp(g: (Int, Int) => Int): Int = {
  g(a, b)
}

3. 接着执行下面内容，返回函数 add

{
  System.out.println("======")
  add
}

4. 传入函数 add 到临时函数 temp，执行：

{
  System.out.println("------")
  g(a, b)
}

---

总结

对于柯里化函数：

def f2(a: Int, b: Int)(g: (Int, Int) => Int): Int = {
  System.out.println("------")
  g(a, b)
}

执行：

f2(a, b) {
  System.out.println("======")
  add
}

执行过程如下：

• f2(a, b) 生成临时函数
• 执行后续代码，获取类型为 (Int, Int) => Int 的函数
• 将上面的函数作为参数传入 f2(a: Int, b: Int)(g: (Int, Int) => Int): Int
• 执行 f2 的函数体
• 完毕