《Kotlin 程序设计》第六章 Kotlin 函数式编程(FP)

  1. 云栖社区>
  2. 博客>
  3. 正文

《Kotlin 程序设计》第六章 Kotlin 函数式编程(FP)

程序员诗人 2017-05-29 03:38:00 浏览769
展开阅读全文

第六章 Kotlin 函数式编程(FP)

正式上架:《Kotlin极简教程》Official on shelves: Kotlin Programming minimalist tutorial
京东JD:https://item.jd.com/12181725.html
天猫Tmall:https://detail.tmall.com/item.htm?id=558540170670

1. 函数式编程概述

从本质上来说, 程序就是一系列有序执行的指令集合。 如何将指令集合组织成可靠可用可信赖的软件(美妙的逻辑之塔), 这是个问题。

首先,什么是函数式编程,这并没有唯一定义,它只是广泛聚合了一些编程风格的特性,我们可以将它与面向对象编程OOP进行对比, 两者区别是,OOP主要聚焦于数据的区别,而FP则注重数据结构的一致性。

函数编程(简称FP)不只代指Haskell Scala等之类的语言,还表示一种编程思维,软件思考方式,也称面向函数编程。

编程的本质是组合,组合的本质是范畴Category,而范畴是函数的组合。

面向对象编程OOP特征:

  • 数据和对数据的操作紧紧耦合
  • 对象隐藏它们操作的实现细节,其他对象调用这些操作只需要通过接口。
  • 核心抽象模型是数据自己
  • 核心活动是组合新对象和拓展已经存在的对象,通过加入新的方法实现。

函数式编程FP特征:

  • 数据与函数是松耦合的
  • 函数隐藏了它们的实现,语言的抽象是函数,以及将函数组合起来表达。
  • 核心抽象模型是函数,不是数据结构
  • 核心活动是编写新的函数。
  • 变量缺省是不变的,减少可变性变量的使用,并发性好[1]

如果说OOP还有很多人可能受静态数据思路影响,那么FP 带来完全是动态事件,FP让我们直接用动词思考,用函数解决问题。

面向对象和面向函数一直在争论,实际上纯粹的OOP和纯粹的FP都是极端的,对于OOP来讲:存在的并一定都是对象,函数就不是对象;对于FP来说:存在的并不总是纯粹的,副作用总是真实存在。

总之,面向对象侧重于自顶向下架构层层分解,函数编程侧重于自底向上层层组合。

2. Kotlin函数式编程

Kotlin对函数式编程的实现恰到好处。

2.1 函数是什么?

在数学中,我们这样定义一个函数:

给定一个集合A,对A施加对应法则f, 记作f(A), 得到另一集合B, 也就是B=f(A). 我们记作:
** f: A -> B **
这个关系式就叫函数关系式, 简称函数.

函数的类型是: A->B。 意思是,if A then , we have B = f(A) . 函数代表一种关系 f 的蕴涵逻辑流。这种蕴涵逻辑流,其实就是映射(Mapping)。

一切皆是映射。

我们说组合是编程的本质,其实,组合就是建立映射关系。

我们说,

程序 = 算法+数据结构

我们把程序看做图论里面的一张图G,这里的数据结构就是图G的节点Node, 而算法逻辑就是这些节点Node之间的Edge。整个的图G就是一幅美妙的抽象逻辑之塔的** 映射图 **。

2.2 函数指针

我们使用::引用一个函数。

/**
 * "Callable References" or "Feature Literals", i.e. an ability to pass
 * named functions or properties as values. Users often ask
 * "I have a foo() function, how do I pass it as an argument?".
 * The answer is: "you prefix it with a `::`".
 */

fun main(args: Array<String>) {
    val numbers = listOf(1, 2, 3)
    println(numbers.filter(::isOdd))
}

fun isOdd(x: Int) = x % 2 != 0

运行结果: [1, 3]

2.3 复合函数(高阶函数(Higher-order function))

函数式编程风格让我们复合函数的写法跟数学表达式一样简洁。看了下面的复合函数的例子,你会发现Kotlin的FP的实现相当简洁,跟纯数学的表达式,相当接近了:

/**
 * The composition function return a composition of two functions passed to it:
 * compose(f, g) = f(g(*)).
 * Now, you can apply it to callable references.
 */

fun main(args: Array<String>) {
    val oddLength = compose(::isOdd, ::length)
    val strings = listOf("a", "ab", "abc")
    println(strings.filter(oddLength))
}

fun isOdd(x: Int) = x % 2 != 0
fun length(s: String) = s.length

fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}


运行结果: [a,abc]

简单说明下

val oddLength = compose(::isOdd, ::length)
    val strings = listOf("a", "ab", "abc")
    println(strings.filter(oddLength))

这就是数学中,复合函数的定义:

h = h(f(g))

g: A->B
f: B->C
h: A->C

g(A)=B
h(A) = f(B) = f(g(A)) = C

只是代码中的写法是:

h=compose( f, g )
h=compose( f(g(A)), g(A) )

/**
 * The composition function return a composition of two functions passed to it:
 * compose(f, g) = f(g(*)).
 * Now, you can apply it to callable references.
 */

fun main(args: Array<String>) {
    val oddLength = compose(::isOdd, ::length)
    val strings = listOf("a", "ab", "abc")
    println(strings.filter(oddLength))
    
    println(strings.filter(::hasA))
    println(strings.filter(::hasB))
    
    val hasBStrings = strings.filter(::hasB)
    println(hasBStrings)
    
    val evenLength = compose(::isEven,::length)
    println(hasBStrings.filter(evenLength))
    
    
}

fun isOdd(x: Int) = x % 2 != 0
fun isEven(x:Int) = x % 2 == 0
fun length(s: String) = s.length
fun hasA(x: String) = x.contains("a")
fun hasB(x: String) = x.contains("b")



fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}

fun <W,X,Y,Z> compose2( h: (Y) -> Z, f:(X) -> Y,g:(W) -> X): (W) -> Z {
    return  {x -> h(f(g(x)))} 
}



你看这个复合函数

fun <W,X,Y,Z> compose2( h: (Y) -> Z, f:(X) -> Y,g:(W) -> X): (W) -> Z {
    return  {x -> h(f(g(x)))} 
}

看起来很像数学定义,语言可谓优雅漂亮,看着很舒服。

运行结果:

[a, abc]
[a, ab, abc]
[ab, abc]
[ab, abc]
[ab]

2.4 闭包(Lambda表达式,匿名函数)

我们知道,函数名其实就是一个指向函数的引用变量。如果没有这样一个显式的变量名,编译器当然也会给这段代码按照一个默认规则,创造一个默认的引用。本质其实就是指令中断现场的地址的存储,执行完一段代码(函数逻辑)之后再返回执行之前的地址,继续执行下面的代码。

函数与闭包(匿名函数、无名函数)是 Kotlin 语言提供的重要特性之一。Kotlin的闭包跟Groovy的闭包使用起来类似,直截了当。

在 Kotlin 中与其说一等公民是函数,不如说一等公民是闭包。

例如在 Kotlin 中,你可以写出这种怪异的代码

fun main(args: Array<String>) {
    test
}
val test = if (5 > 3) {
    print("yes")
} else {
    print("no")
}

这段代码会输出yes。

这里的if 语句,就是一个闭包。

我们说的Lambda 表达式,就是匿名函数,就是闭包。而匿名函数(闭包),就是匿名的功能代码块了。

Lambda表达式基于数学中的λ演算得名,Lambda表达式可以表示闭包(注意和数学传统意义上的不同)。

Lambda表达式基本语法如下:

  • Lambda表达一般使用{ }包围。
  • 参数(如果有的话)在->前定义,参数类型可能是省略的。
  • 函数体跟在->后面。

我们先来看一个 Lambda 表达式的例子:


// LambdaExpression.kt
package com.easy.kotlin

/**
 * Created by jack on 2017/5/30.
 */

//    Lambda 表达式
val fsum0 = { x: Int, y: Int ->  x + y  }
val fsum1 = { x: Int, y: Int -> { x + y } }
val fsum2 = fun(x: Int, y: Int): Int = x + y
val fsum3 = fun Int.(other: Int): Int = this + other


fun main(args: Array<String>) {
    println(fsum0(1, 1))
    println(fsum0.invoke(1,1))

    println(fsum1(1, 1).invoke())
    println(fsum2(1, 1))
    println(1.fsum3(1))

}

可以看到我们定义了一个变量 fsum0,赋值为一个 Lambda 表达式:

{ x: Int, y: Int -> x + y }

Lambda 表达式用一对大括号括起来,后面先依次写下参数及其类型,如果没有就不写,接着写下-> ,这表明后面的是函数体了,函数体的最后一句的表达式结果就是 Lambda 表达式的返回值,比如这里的返回值就是参数求和的结果。

后面我们用 () 的形式: fsum0(1, 1) 调用这个 Lambda 表达式,其实这个 () 对应的是 invoke 方法,换句话说,我们在这里也可以这么写:

fsum0.invoke(1,1)

这两种调用的写法是完全等价的。

我们看到 val fsum1 = { x: Int, y: Int -> { x + y } } 这一句, 跟fsum0相比,函数体多了个{}。 意思就大不同了。这表明fsum1本身就是一个函数。其调用方式为:

fsum1(1, 1).invoke()

再看 val fsum3 = fun Int.(other: Int): Int = this + other , 匿名函数语法允许我们直接指定函数字面值的接收者类型(这里是Int)。然后,我们直接这样调用函数:1.fsum3(1)

我们用kotlinc编译LambdaExpression.kt之后,发现目录下生成了这么多的类

./LambdaExpression.kt
./LambdaExpressionKt$fsum0$1.class
./LambdaExpressionKt$fsum1$1$1.class
./LambdaExpressionKt$fsum1$1.class
./LambdaExpressionKt$fsum2$1.class
./LambdaExpressionKt$fsum3$1.class
./LambdaExpressionKt.class

这个我们很熟悉,就是Java中我们看到的内部类。默认命名规则依然是熟悉的配方:$1, $2 ...

我们看这一行

val fsum1 = { x: Int, y: Int -> { x + y } }

对应编译成了两个类文件:

./LambdaExpressionKt$fsum1$1$1.class 
./LambdaExpressionKt$fsum1$1.class

其中,./LambdaExpressionKt$fsum1$1$1.class 对应 val fsum1 = { x: Int, y: Int -> { x + y } } 中的{ x + y }

./LambdaExpressionKt$fsum1$1.class 对应的是 val fsum1 = { ... } 外面的 { }

自执行闭包就是在定义闭包的同时直接执行闭包,一般用于初始化上下文环境。 例如:

{ x: Int, y: Int ->
    println("${x + y}")
}(1, 3)

闭包(Lambda表达式,匿名函数),在Thread线程执行逻辑里面就显得非常简洁了:

    fun testThread() {
        val startHookThread = Thread({
            println("Hello, I am startHookThread")
        })
        startHookThread.start()
    }

我们会觉得,代码就应该这么写。而不像之前在Java中,要写上一堆样板代码。在Java 8中,也支持了Lambda表达式,写法简洁了许多了。

不过,虽然我们写代码的时候,没有给这段代码块名字, 但是真正到了指令级代码的时候, 还是需要名字的。所以,编译器在处理的时候,会自动给这段匿名函数生成一个名字的

这段代码,kotlinc编译成了:

// access flags 0x1A
  // signature (Lkotlin/jvm/internal/Ref$ObjectRef<Ljava/lang/String;>;Ljava/lang/String;)V
  // declaration: void kotlin$lambda-0(kotlin.jvm.internal.Ref$ObjectRef<java.lang.String>, java.lang.String)
  private final static kotlin$lambda-0(Lkotlin/jvm/internal/Ref$ObjectRef;Ljava/lang/String;)V
    ALOAD 1
    INVOKESTATIC kotlin/io/ConsoleKt.println (Ljava/lang/Object;)V
    ALOAD 0
    NEW java/lang/StringBuilder
    DUP
    ALOAD 0
    GETFIELD kotlin/jvm/internal/Ref$ObjectRef.element : Ljava/lang/Object;
    CHECKCAST java/lang/String
    INVOKESPECIAL java/lang/StringBuilder.<init> (Ljava/lang/String;)V
    ALOAD 1
    INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
    INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
    PUTFIELD kotlin/jvm/internal/Ref$ObjectRef.element : Ljava/lang/Object;
    RETURN
   L0
   L1
    MAXSTACK = 4
    MAXLOCALS = 2

  // access flags 0x11
  public final testThread()V
    NEW java/lang/Thread
    DUP
    INVOKESTATIC jason/chen/mini_springboot/restful/service/KotlincService.testThread$lambda-0 ()V
    ACONST_NULL
   L0
    INVOKESPECIAL java/lang/Thread.<init> (Lkotlin/jvm/functions/Function0;)V
    ASTORE 1
   L1
    ALOAD 1
    INVOKEVIRTUAL java/lang/Thread.start ()V
    RETURN
   L2
    LOCALVARIABLE startHookThread Ljava/lang/Thread; L1 L2 1
    MAXSTACK = 3
    MAXLOCALS = 2

  // access flags 0x1A
  private final static testThread$lambda-0()V
    LDC "Hello, I am startHookThread"
    INVOKESTATIC kotlin/io/ConsoleKt.println (Ljava/lang/Object;)V
    RETURN
   L0
   L1
    MAXSTACK = 1
    MAXLOCALS = 0

我们可以看出,在testThread()函数里面,有这么一段代码:

NEW java/lang/Thread
    DUP
    INVOKESTATIC jason/chen/mini_springboot/restful/service/KotlincService.testThread$lambda-0 ()V
    ACONST_NULL
   L0
    INVOKESPECIAL java/lang/Thread.<init> (Lkotlin/jvm/functions/Function0;)V

其中,$lambda-0() 函数签名如下:

private final static kotlin$lambda-0(Lkotlin/jvm/internal/Ref$ObjectRef;Ljava/lang/String;)

这就是闭包(匿名函数,Lambda表达式)背后真正的执行过程。更多的事情,由编译器去完成了。

Kotlin编译器在编译前端(即词法分析、语法分析、语义分析、中间代码生成)和Java是基本一致的。与Java不同的地方在编译后面的目标代码生成环节。Kotlin编译器在目标代码生成环节做了很多类似于Java封装的事情,比如自动生成Getter/Setter代码、Companion Object转变成静态类、修改类属性为final不可继承等等工作。大部分Kotlin的特性都在这个环节处理产生。可以这么说,Kotlin将我们本来在代码层做的一些封装工作转移到了编译后端阶段,以使得我们可以更加简洁的使用Kotlin语言。

感谢Kotlin编译器,让我们能够很享受地用kotlin写代码。

2.5 filter函数

    val ints = intArrayOf(-1, -2, 3, 4, 5, 6)
    var sum = 0
    ints.filter { it > 0 }.forEach {
        sum = it.fsum3(sum)
        //sum += it;
    }
    println(sum)//18

这里的forEach函数

/**
 * Performs the given [action] on each element.
 */
@kotlin.internal.HidesMembers
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

是kotlin.collections._Collections.kt里面的一个扩展方法。

2.6 map函数

    val doubled = ints.map { value -> value * 2 }
    println(doubled)

参考资料

1.http://www.jdon.com/functional.html

网友评论

登录后评论
0/500
评论