Android advanced Kotlin high-order function principle and Standard.kt source code detailed explanation

[[415708]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

In Kotlin, a higher-order function is a function that is used as a parameter or return value of another function. If f(x) and g(x) are used to represent two functions, then the higher-order function can be represented as f(g(x)). Kotlin provides developers with a wealth of higher-order functions, such as let, with, apply in Standard.kt, forEach in _Collectioins.kt, etc. In order to be able to use these higher-order functions freely, it is necessary to understand how to use these higher-order functions.

Today we will explain higher-order functions

1. Detailed explanation of higher-order functions

1. What are higher-order functions?

• If a function receives another function as an argument or returns a value of type another function, then the function is called a higher-order function.
• Unlike Java, Kotlin adds the concept of a function type. If we add this type of function to the parameter declaration or return value declaration of a function, then this is a higher-order function.
• Function type syntax basic rules: (String, Int) -> Unit added to a function's parameter declaration

 public fun test2(test: Int ,block:()->Unit){
 var v = block()
        DTLog.i( "TestTest" , "Test1" )
 }
 public fun <T>T.test22(block:()->T):T{
 return block()
 }
 public fun <T>T.test26(block:T.()->Unit){
 block()
 }
 public fun <T>T.test23(block:(T)->Unit):T{
 return this
 }
 public fun <T,R> T.test3(block: (T) -> R):R{
 var t = block(this)
 return t
 }
 public fun <T, W> T.test4(block: (T) -> W): W {
 return block(this)
 }

The above is a high-order function, which receives a parameter of function type. The method of calling a high-order function is not much different from calling a normal function. You only need to add parentheses after the parameter name and pass the necessary parameters in the parentheses.

Higher-order function types have a special notation corresponding to the function signature, i.e. their parameters and return value:

• All function types have a parameter type list enclosed in parentheses and a return type: (A, B) -> C represents a function type that accepts two parameters of type A and B and returns a value of type C. The parameter type list can be empty, such as () -> A, and the return value can be empty, such as (A, B) -> Unit;
• Function types can have an additional receiver type, which is specified before the dot in the notation, such that the type A.(B) -> C means that a function with type B as an argument and returning a value of type C can be called on a receiver object of A.
• There is also a special type of function, the suspend function, which has a suspend modifier in its representation, for example suspend () -> Unit or suspend A.(B) -> C.

2. Detailed explanation of inline functions

①What is an inline function?

inline (be careful, not online), translated as "inline" or "embedded". It means: when the compiler finds that a certain section of code is calling an inline function, it does not call the function, but inserts the entire code of the function into the current position. The advantage of this is that it saves the calling process and speeds up the program. (The function calling process always takes more time due to the operations such as pushing parameters into the stack as mentioned above). The disadvantage of this is: since every time the code calls an inline function, it is necessary to directly insert a section of the function's code at the call site, the size of the program will increase. To use a life phenomenon as an analogy, it's like the TV is broken, and you call a repairman, you will think it's too slow, so you just keep a repairman at home. This is of course faster, but the repairman living in your house will take up space. Inline functions are not necessary, they are just a modification to increase speed. To modify a function to inline type

Use the following format:

inline function declaration or definition

In a nutshell, add an inline modifier before the function declaration or definition.

 inline int   max ( int ​​a, int b)
 {
 return (a>b)? a : b;
 }

The essence of inline functions is that they save time but consume space.

② Inline function rules

Rules for inline functions

(1) A function can call itself, which is called recursive call (discussed later). Functions containing recursive calls cannot be set to inline;

(2) Complex flow control statements are used: loop statements and switch statements cannot be set to inline;

(3) Due to the fact that inline functions increase the size of a function, it is recommended that the code in an inline function should be very short, preferably no longer than 5 lines.

(4) Inline is only a "request". In certain cases, the compiler will ignore the inline keyword and force the function to become a normal function. In this case, the compiler will give a warning message.

(5) Before you call an inline function, the function must have been declared or defined as inline before. If it is declared as a normal function before and defined as an inline function after the calling code, the program can be compiled, but the function is not inlined. For example, the following code snippet:

//The function was not initially declared as inline:

void foo();

//Then there is code to call it:

foo();

//The function is defined as inline only after the call:

 inline void foo()
 {
 ......
 }

The code shows that the foo() function does not implement inline at the end;

(6) For debugging convenience, all inline functions are not implemented when the program is in the debugging phase.

③When inlining functions, pay attention to the following issues

(1) Inline functions defined in one file cannot be used in another file. They are usually placed in header files for sharing.

(2) An inline function should be concise, with only a few statements. If there are more statements, it is not suitable to be defined as an inline function.

(3) An inline function body cannot contain loop statements, if statements, or switch statements. Otherwise, the compiler will treat the function as a non-inline function even if the inline keyword is included in the function definition.

(4) Inline functions must be declared before they are called. The keyword inline must be placed together with the function definition body to make the function inline. Simply placing inline before the function declaration will not have any effect.

3. Using inline functions in higher-order functions

The Lambda expressions that are used all the time are converted into anonymous class implementations at the bottom layer. This means that every time we call a Lambda expression, a new anonymous class instance will be created, which will of course cause additional memory and performance overhead. To solve this problem, Kotlin provides the inline function, which can completely eliminate the runtime overhead caused by using Lambda expressions. You only need to add the inline keyword declaration when defining a higher-order function.

 inline fun test111(num1: Int , num2: Int , block: ( Int , Int ) -> Int ): Int {
        val result = block(num1, num2)
 return result
 }

4. Closure function

The return value of a function is a function, and the function contains another function inside, which can be an anonymous function with or without parameters.

 fun main(args: Array<String>) {
 val mm = aaa()
 println(mm())
 println(mm())
 println(mm())
 println(mm())
 println(mm())
 val kk = bbb()
    println(kk( "shadow" )) //shadow --- 1  
    println(kk( "shadow" )) //shadow --- 2  
    println(kk( "shadow" )) //shadow --- 3  
    println(kk( "shadow" )) //shadow --- 4  
    println(kk( "shadow" )) //shadow --- 5  
 }
 //The closure function is the function as the return parameter
 fun aaa(): () -> ( Int ) {
 var current = 10
 return fun(): Int {
 return   current ++
 }
 }
 fun bbb(): (String) -> (String) {
 var current = 0;
 return fun(str: String): String {
 current ++;
 return   "$str --- $current" ;
 }
 }

2. Explanation of the source code of the standard library Standard.kt in kotin

The Standard.kt standard library of Kotlin source code provides some convenient built-in high-order functions (let, also, with, run, apply), which can help us write more concise and elegant Kotlin code and improve development efficiency. Studying the source code can help us understand and apply it faster.

1. Apply

 @kotlin.internal.InlineOnly
 public inline fun <T> T.apply(block: T.() -> Unit): T {
 contract
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 block()
 return this
 }

• Pass this as the block function parameter (can be omitted when calling), and the return value of the apply function is the caller itself;
• Execute a method, variable, etc. in type T, and then return itself T;
• Note the parameter block: T.(). Whenever you see a code block like block: T.() ->, it means that you can directly call the API inside T in the curly braces {} without adding T. This [actually calls this., which is usually omitted]

val str = "hello"

str.apply { length } // str can be omitted.

str.apply { this.length } //You can do this

2. let

 @kotlin.internal.InlineOnly
 public inline fun <T, R> T.let(block: (T) -> R): R {
 contract
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block(this)
 }

• The let method is passed type T and returns another type R form;
• Pass it as the block function parameter, and the return value of the let function is determined by the block function;

3. also

 @kotlin.internal.InlineOnly
 @SinceKotlin( "1.1" )
 public inline fun <T> T.also(block: (T) -> Unit): T {
 contract
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 block(this)
 return this
 }

Execute a method, variable, etc. in type T, and then return itself T;

Pass it as the block function parameter (cannot be omitted when calling), and the return value of the also function is the caller itself;

This method is similar to the apply method above, except that when executing T's own method in the curly braces, T must be added. Otherwise, the API in T cannot be called. What does this mean? Look at the following code:

val str = "hello"

str.also { str.length } //str. must be added, otherwise the compilation will report an error

str.also { it.length } //Or use it.

4. with

 @kotlin.internal.InlineOnly
 public inline fun <T, R> with (receiver: T, block: T.() -> R): R {
 contract
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return receiver.block()
 }

• The with() method accepts a parameter of type T and a code block.
• After processing, an R type result is returned

 val str = "hello"  
 val ch = with (str) {
 get(0)
 }
 println(ch) //print h

5. run

 @kotlin.internal.InlineOnly
 public inline fun <R> run(block: () -> R): R {
 contract
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block()
 }

• It requires a code block to be passed and returns an arbitrary type;
• Whenever a function receives a code block, it is generally recommended to use {} to enclose the logic in the code block. Only in some special cases can it be simplified in the form of parameters (::fun).

 @kotlin.internal.InlineOnly
 public inline fun <T, R> T.run(block: T.() -> R): R {
 contract
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block()
 }

• Here, a run method of type T is executed, and a code block is still passed.
• It just executes a variable or method inside T, and returns an R type.

 run {
 println(888)
 }
 val res = run { 2 + 3 }
 fun runDemo() {
 println( "test run method" )
 }
 //We can do this
 run(::runDemo)

6. takeIf

 public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
 contract
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
 }
 return if (predicate(this)) this else   null  
 }

• Make an internal judgment based on the passed parameter T, and return null or T itself based on the judgment result;
• What is passed is a [unary predicate] code block, which is very similar to the unary predicate in C++: the method has only one parameter and the return type is Boolean;
• In the source code, the passed unary predicate code block is used for judgment. If it is true, it returns itself, otherwise it returns null;

 val str = "helloWorld"  
 str.takeIf { str. contains ( "hello" ) }?.run(::println)

7. takeUnless

 public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
 contract
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
 }
 return if (!predicate(this)) this else   null  
 }

This method is similar to the takeIf() method, except that it returns T itself when the internal judgment is false, and returns null when it is true. Therefore, we will not explain it in detail. Please refer to the takeIf() method for details.

8. repeat()

 public inline fun repeat(times: Int , action : ( Int ) -> Unit) {
    contract { callsInPlace( action ) }
 for ( index   in 0 until times) {
 action ( index )
 }
 }

Analysis: The repeat method contains two parameters:

• The first parameter is of type int, the number of repetitions.
• The second parameter indicates the object to be executed repeatedly
• Each time this method is executed, the number of executions is passed to the module to be repeatedly executed. Whether the repeatedly executed module needs this value depends on the actual business needs. For example:

//Print values ​​from 0 to 100, the number of times uses the internal index

 repeat(100) {
 print(it)
 }
 //For example, simply printing helloworld 100 times does not use the index value
 repeat(100){
 println( "helloworld" )
 }

3. High-order function selection

• If you need to return the caller itself (i.e. return this), you can choose to apply also
• If you need to pass this as a parameter, you can choose apply run with
• If you need to pass it as a parameter, you can select let also
• If the return value needs to be determined by the function (i.e. return block()), you can choose run with let

Summarize

Whether it is a built-in high-order function in Kotlin or a custom one, the code block styles passed in are nothing more than the following:

1. block: () -> T and block: () -> specific type

When using the (::fun) form of simplification, the method passed in must be parameterless, and the return value type can be any type if it is T, otherwise the return type must be consistent with the return type of this code block

2. block: T.() -> R and block: T.() -> specific type

When using the (::fun) form of simplification, the method passed in must contain a parameter of type T, and the return value type can be any type if it is R, otherwise the return type must be consistent with the return type of the code block. For example, the two methods with and apply

3. block: (T) -> R and block: (T) -> specific type

When using the (::fun) form of simplification, the method passed in must contain a parameter of type T. If the return value type is R, it can be any type. Otherwise, the return type must be consistent with the return type of the code block. For example, the two methods let and takeIf