We already discussed how, if a function's last parameter is a lambda, it can't be passed outside the parenthesis and inside curly braces, as if the lambda itself is the body of a control structure.
We covered this unless function in Chapter 2, Getting Started with Functional Programming, in the section, First-class and high-order functions. Let's have a look at the following code:
fun unless(condition: Boolean, block: () -> Unit) {
if (!condition) block()
}
unless(someBoolean) {
println("You can't access this website")
}
Now, what happens if we combine vararg and lambda? Let's check it in the following code snippet:
fun <T, R> transform(vararg ts: T, f: (T) -> R): List<R> = ts.map(f)
Lambdas can be at the end of a function with a vararg parameter:
transform(1, 2, 3, 4) { i -> i.toString() }
Let's get a little adventurous, a vararg parameter of lambdas:
fun <T> emit(t: T, vararg listeners: (T) -> Unit) = listeners.forEach { listener ->
listener(t)
}
emit(1){i -> println(i)} //Compilation error. Passing value as a vararg is only allowed inside a parenthesized argument list
We can't pass a lambda outside of the parenthesis, but we can pass many lambdas inside:
emit(1, ::println, {i -> println(i * 2)})