《Kotlin极简教程》第六章 Kotlin函数式编程（FP）

时间：2025-02-08 12:36:50

Kotlin对函数式编程的实现恰到好处。
最新上架！！！
《 Kotlin极简教程》 陈光剑 （机械工业出版社）:
/s/bzRkGSO6T1O2AELM_UqKUQ

函数指针

/**
 * "Callable References" or "Feature Literals", . 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((::isOdd))
}

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

运行结果： [1, 3]

复合函数

看了下面的复合函数的例子，你会发现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((oddLength))
}

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

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((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((oddLength))
    
    println((::hasA))
    println((::hasB))
    
    val hasBStrings = (::hasB)
    println(hasBStrings)
    
    val evenLength = compose(::isEven,::length)
    println((evenLength))
    
    
}

fun isOdd(x: Int) = x % 2 != 0
fun isEven(x:Int) = x % 2 == 0
fun length(s: String) = 
fun hasA(x: String) = ("a")
fun hasB(x: String) = ("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)))} 
}

运行结果：

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

相关文章