《Kotlin 程序设计》第六章 Kotlin 函数式编程（FP）第六章 Kotlin 函数式编程（FP）1. 函数式编程概述2. Kotlin函数式编程参考资料

/**
 * "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

/**
 * 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)) }
}

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

/**
 * 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]

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

// 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))

}

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

fsum0.invoke(1,1)

fsum1(1, 1).invoke()

./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

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

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

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

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

// 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

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

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

    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

/**
 * 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)
}

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