kotlin 中的多个高阶函数

Question

Can we pass two higher order functions or more than one, in function's parameter?
If so, then how we going to call that function which contain those two or more than one higher order functions as a parameter...

Answer 1

Of couse you can. You can have any number of lambda parameters just like for parameters of any other type.

Even Kotlins standard library makes use of that. For example the generateSequence function.

generateSequence(seedFunction = { 1 }, nextFunction = { it + 1 })

The only difference to a non-lambda parameter is that you can omit the parentheses if the last parameter of your function is a lambda. So you could call generateSequence like this too:

generateSequence(seedFunction = { 1 }) { it + 1 }

Answer 2

Wording

There might be a misunderstanding of what a Higher-Order function is:
GeeksForGeeks :

In Kotlin, a function which can accepts a function as parameter or can returns a function is called Higher-Order function.

And now the definition for functions:

Kotlinlang:

Kotlin functions are first-class, which means that they can be stored in variables and data structures, passed as arguments to and returned from other higher-order functions. You can operate with functions in any way that is possible for other non-function values.

Conclusion

Functions can be passed as parameters into methods - just as many as you like. High-order is just a (descriptive) type, which means that your method either takes functions as parameters, or returns a function.

Example:

fun <T> takeFiveFunctions(
    block1 : () -> Unit,
    block2 : (T) -> Unit,
    block3 : () -> T,
    block4 : (T) -> T,
    block5 : (List<T>) -> T
) : Boolean = true

fun main() {
    takeFiveFunctions<Int>(
        block1 = { /*do something 1*/ },
        block2 = { print(it) },
        block3 = { 2 },
        block4 = { it * 3 },
        block5 = { it.first() }
    )
}

EDIT

but some other syntax says we can take out lambda from parentheses

Kotlinlang says :

In Kotlin, there is a convention: if the last parameter of a function is a function, then a lambda expression passed as the corresponding argument can be placed outside the parentheses:

Using my previous example, it would look like this:

fun main() {
    takeFiveFunctions<Int>(
        block1 = { /*do something 1*/ },
        block2 = { print(it) },
        block3 = { 2 },
        block4 = { it * 3 }
    ) { it.first()}
}

Answer 3

Yes, why not. You can just do that:

fun <T1, T2, T3> Collection<T1>.higherOrder(
  firstFun: (T1)->T2,
  secondFun: (T2)->T3)
: List<T3> {
  return this.map(firstFun).map(secondFun)
}

Invocation:

val result = listOf(3.14, 6.9, 42.0).higherOrder({ it.toInt() }, { it.toString() })
// ["3", "6", "42"]

Kotlin allows to move last lambda parameter outside parameter list, so you can also write:

val result = listOf(3.14, 6.9, 42.0).higherOrder({ it.toInt() }) { it.toString() }

But in case of multiple functional parameters, that's bad practice. The best you can do is to specify parameter names explicitly:

val result = listOf(3.14, 6.9, 42.0).higherOrder(
  firstFun = { it.toInt() }, 
  secondFun = { it.toString() }
)

Which is much more readable.