1. 函数编程中,可以接受多个参数的函数都可以转换为接受单个参数的函数,这个转化过程就叫柯里化
  2. 柯里化就是证明了函数只需要一个参数而已。其实我们刚才学习的过程中,已经使用到了函数柯里化
  3. 不用设立柯里化存在意义这样的命题。柯里化就是以函数为主题这种思想发展必然产生的结果

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.sky.scala.exercise17

object HigherCurryDemo {
  def main(args: Array[String]): Unit = {
    def eq(s: String, ss: String): Boolean = {
      s.equals(ss)
    }

    val str = "hello"

    println(str.checkEq("HELLO")(eq))

    println(str.checkEq("Hello!!")(_.equals(_)))
  }

  implicit class testEq(s: String) {
    def checkEq(ss: String)(f: (String, String) => Boolean) = {
      f(s.toUpperCase(), ss.toUpperCase())
    }
  }

}

高级部分,控制抽象

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.sky.scala.exercise17

object CurryAbstractControl {
  def main(args: Array[String]): Unit = {
    //    方法调用方式一
    run {
      () => {
        println("开始执行任务")
        Thread.sleep(5000)
        println("任务执行完毕")
      }
    }
    //    方法调用方式二

    //    对于没有输入,没有返回值,可以简写为如下形式,去掉run2方法中的()参数
    run2 {
      println("开始执行任务")
      Thread.sleep(5000)
      println("任务执行完毕")
    }

  }

  def run(f: () => Unit): Unit = {
    new Thread() {
      override def run(): Unit = {
        f()
      }
    }.start()
  }

  def run2(f: => Unit): Unit = {
    new Thread() {
      override def run(): Unit = {
        f
      }
    }.start()
  }
}

控制抽象

进阶用法,实现类是While的Until语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.sky.scala.exercise17

object AbstractControlUntil {
  def main(args: Array[String]): Unit = {
    var i = 10
    until(i > 0) {
      i -= 1
      println(i)
    }
  }

  def until(condition: => Boolean)(block: => Unit): Unit = {
    if (condition) {
      block
      until(condition)(block)
    }
  }
}