scala学习笔记（四）

Higher-Order Functions

以其他函数作为参数或者返回值的函数，被称为higher-order functions

  def sum(f: Int => Int, a: Int, b: Int): Int =
    if (a > b) 0
    else f(a) + sum(f, a + 1, b)
    
  def sumInts(a: Int, b: Int) = sum(id, a, b)
  def sumCubes(a: Int, b: Int) = sum(cube, a, b)
  def sumFactorials(a: Int, b: Int) = sum(fact, a, b)
  
  def id(x: Int): Int = x
  def cube(x: Int): Int = x * x * x
  def fact(x: Int): Int = if (x == 0) 1 else fact(x - 1)

Anonymous Function

匿名函数举例

(x: Int) => x * x * x

匿名函数通常被表示为

{def f(x1: T1,..., xn: Tn) = E;f}

f 是任意的。
有时匿名函数的参数类型是可以被省略的，如果编译器可以从环境中推断到。
运用匿名函数可以简化函数，可以免去冗杂的函数定义，使整体看起来更简洁易读。

  def sumInts(a: Int, b: Int) = sum(x =>  x, a, b)
  def sumCubes(a: Int, b: Int) = sum(x => x * x * x, a, b)

Lecture 2.1 课堂测验

完成累和

  def sum(f: Int => Int, a: Int, b: Int): Int = {
    def loop(a: Int, acc: Int): Int = {
      if (a>b) acc
      else loop(a+1, acc+f(a))
    }
    loop(a, 0)
  } 
  sum(x => x * x, 5, 8) 

###Currying
Currying（柯里化）

对于sum函数完成进一步简化，去除冗余的参数 a,b，避免每个函数都带有同样的参数

  def sum(f: Int => Int): (Int, Int) => Int = {
    def sumF(a: Int, b: Int): Int =
      if (a > b) 0
      else f(a) + sumF(a + 1, b)
    sumF
  }  
  def sumInts = sum(x => x)
  def sumCubes = sum(x => x * x * x)
  def sumFactorials = sum(fact)

由sum的代码，我们可以看出，sum只有一个参数f，这个f的参数是int，返回也是int，我们再看sum的返回，sum返回的是一个函数，返回的是sumF，它的参数是两个int，返回一个int。
所以才能完成如下计算

sumCubes(1,10) + sumFactorials(10,20)

进一步思考，我们是否可以避免定义那么多函数sumInts，sumCubes，而把它们进行合并呢，就类似与函数重载，结论是当然可以

sum(cube)(1,10)

我们发现现在sum函数拥有两个参数，一个是cube，一个是两个int，对于这样的形式，我们先将cube函数输入到sum中，返回sum of cubes函数，然后再代入参数(1,10), 换言之，就是我们从左到右依次代入参数。于是我们定义

  def sum(f: Int => Int)(a: Int, b: Int): Int =
    if (a > b) 0 else f(a) + sum(f)(a + 1, b)

一般而言，我们定义带有多个参数的函数

def f(args1)...(argsn) = E

当n>1, 上述函数等价于

def f(args1)...(argsn-1) = {def g(argsn) = E;g}

def f(args1)...(argsn-1) = (argsn => E)

如果我们反复进行上述操作，那么函数将变成

def f = (args1 => (args2 =>...(argsn => E)...))

这里我们终于迎来了Currying，上述这种方程的定义和应用就叫做Currying，即将接受多个参数的方程转化为一系列接受一个参数的方程。

Lecture 2.2 课堂测验

写一个累乘函数

  def product(f: Int => Int)(a: Int, b: Int): Int =
    if (a > b) 1
    else f(a) * product(f)(a + 1, b)

在累乘函数的基础上写factorial

  def fact(n: Int) = product(x => x)(1, n) 

写一个泛化函数可以涵盖乘法和加法

  def mapReduce(f: Int => Int, combine: (Int, Int) => Int, zero: Int)(a: Int, b: Int): Int =
    if (a > b) zero
    else combine(f(a), mapReduce(f, combine, zero)(a + 1, b))