[kotlin] Introduction to higher-order functions

What is a higher-order function

A function that takes a function as an argument or returns a value , Called higher order function .

Define higher-order functions

action It's a function of higher order ,(Int) -> Int Indicates the type of the function ,（Int） Indicates that the input parameter type of the function is Int, hinder Int Indicates the return type of the function .

 private fun init() {
        val action: ((Int) -> Int) = {// Function to add 100 operation 
            it + 100
        }
    } 

Function as parameter

The following code ,init Function call doSomething function , take Int type 0 as well as action Function is introduced to doSomething.doSomething The function first aligns the parameters 0 add 200 operation , Then we call the higher-order function. action（ add 100 operation ）, Final print results actionResult. Is it a bit of a strategic design pattern ？ Yes , It can be used to implement the strategy design pattern .

 private fun init() {
        val action: ((Int) -> Int) = {// Function to add 100 operation 
            it + 100
        }
        doSomething(0, action)// take 0 as well as action Pass to doSomething
    }

    private fun doSomething(d: Int, action: (Int) -> Int) {
        val data = d + 200// First pair d add 200 operation 
        val actionResult = action(data)// Will add 200 The result is passed to action, The results are stored in actionResult in 
        Log.e("test", "actionResult=${actionResult}")// Print the results 
    } 

Function as return value

The following code , Depending on the type type, Return the corresponding action, Then the parameters 0 Carry out operations , Final print results .

 override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val action = init(" programme 1")
        // Get the corresponding action, Pass in the parameter 0 Carry out operations 
        val result = action?.invoke(0)
        // Print the results 
        Log.e("test", "result=${result}")
    }


    private fun init(type: String): ((Int) -> Int)? {
        val action1: ((Int) -> Int) = {// Add 100 operation 
            it + 100
        }

        val action2: ((Int) -> Int) = {// Add 200 operation 
            it + 200
        }
        // According to the type type, Return the corresponding action
        return when (type) {
            " programme 1" -> action1
            " programme 2" -> action2
            else -> null
        }
    } 

lamdba expression

It's also a higher-order function , It's just that the function is anonymous . The function of the following code is the same as the above , Just for amdba Expressions replace definitions action function .

private fun init() {
    doSomething(0) { // take 0 as well as lambda The expression is passed to doSomething
        it + 100// add 100 operation , And back to 
    }
}

private fun doSomething(d: Int, action: (Int) -> Unit) {
    val data = d + 200// First pair d add 200 operation 
    val actionResult = action(data)// Will add 200 The result is passed to action, The results are stored in actionResult in 
    Log.e("test", "actionResult=${actionResult}")// Print the results 
} 

What is the essence of higher-order functions ?

Decompile the first example

private static final void init() {
    Function1 action = new Function1() {//1
        @Override
        public Object invoke(Object o) {
            return ((Integer)o).intValue() + 100;//2
        }
    };
    doSomething(0, action);
}

private static final void doSomething(int d, Function1 action) {//3
    int data = d + 200;
    int actionResult = ((Number)action.invoke(data)).intValue();
    Log.e("test", "actionResult=" + actionResult);
} 

• notes 1：Kotlin The compiler converts higher-order functions into Function1;
• notes 2： Implementation of corresponding higher-order function ;
• notes 3： Call higher-order functions , In fact, the trigger is invoke function ;

There is something wrong with the above analysis , Please point out , learn from each other , Thank you ！