scala的高阶函数

一 柯里化

柯里化（Currying）是指将原先接受多个参数的方法转换为多个只有一个参数的参数列表的过程。

程序：

// 柯里化：实现对两个数进行计算
def calc_carried(x:Double, y:Double)(func_calc:(Double, Double)=>Double) = {
    func_calc(x, y)
}

def main(args: Intrray[String]): Unit = {
    println(calc_carried(10.1, 10.2){
        (x,y) => x + y
    })
    println(calc_carried(10, 10)(_ + _))
    println(calc_carried(10.1, 10.2)(_ * _))
    println(calc_carried(100.2, 10)(_ - _))
}

二 闭包

闭包其实就是一个函数，只不过这个函数的返回值依赖于声明在函数外部的变量。

可以简单认为，就是可以访问不在当前作用域范围的一个函数。

val y=10

val add=(x:Int)=>{
    x+y
}

println(add(5)) // 结果15

三 隐式转换和隐式参数

所谓隐式转换，是指以implicit关键字声明的带有单个参数的方法。它是自动被调用的，自动将某种类型转换为另外一种类型。

使用步骤

在object中定义隐式转换方法（使用implicit）
在需要用到隐式转换的地方，引入隐式转换（使用import）
自动调用隐式转化后的方法

package com.xu
import java.io.File

import scala.actors.{Actor, Future}
import scala.io.Source
object ScalaTest {
  class RichFile(val file:File) {
    def read() = {
      Source.fromFile(file).mkString
    }
  }
  object RichFile {
    implicit def file2RichFile(file: File) = new RichFile(file)
  }
  def main(args: Array[String]): Unit = {
    // 加载文件
    val file = new File("./data/1.txt")
    // 导入隐式转换
    import RichFile.file2RichFile
    // file对象具备有read方法
    println(file.read())
  }
}

自动导入隐式转换方法

class RichFile(val f:File) {
  // 将文件中内容读取成字符串
  def read() = Source.fromFile(f).mkString
}

object ImplicitConvertDemo {
  // 定义隐式转换方法
  implicit def file2RichFile(f:File) = new RichFile(f)

  def main(args: Array[String]): Unit = {
    val f = new File("./data/textfiles/1.txt")

    // 调用的其实是RichFile的read方法
    println(f.read())
  }
}

隐式参数

定义
在方法后面添加一个参数列表，参数使用implicit修饰
在object中定义implicit修饰的隐式值
调用方法，可以不传入implicit修饰的参数列表，编译器会自动查找缺省值

// 使用implicit定义一个参数
def quote(what:String)(implicit delimiter:(String, String)) = {
    delimiter._1 + what + delimiter._2
}

// 隐式参数
object ImplicitParam {
    implicit val DEFAULT_DELIMITERS = ("<<<", ">>>")
}

def main(args: Array[String]): Unit = {
    // 导入隐式参数
    import ImplicitParam.DEFAULT_DELIMITERS

    println(quote("李雷和韩梅梅"))
}