Kotlin: Lambdas
Kotlin: Higher-Order_Functions_and_Lambdas
 
Lambda Expressions
Lambda expressions (or function literals) are 
also not bound to any entity such as a class, 
object, or interface. They can be passed as 
arguments to other functions called higher-
order functions.
A lambda expression represents just the block 
of a function, and using them reduces the 
noise in our code. 

If you're a Java coder, you know that Java 8 
and above provides support for lambda 
expressions.

One of the awesome things about Kotlin is 
that lambda expressions are supported out of 
the box. Because lambda is not supported in 
Java 6 or 7, for Kotlin to interoperate with 
it, Kotlin creates a Java anonymous class 
behind the scene. But note that creating a 
lambda expression in Kotlin is quite different 
than it is in Java.

Here are the characteristics of a lambda 
expression in Kotlin:

 - It must be surrounded by curly braces {}.

 - It doesn't have the fun keyword.
  
 - There is no access modifier (private, 
   public or protected) because it doesn't 
   belong to any class, object, or interface.

 - It has no function name. 
   In other words, it's anonymous.
  
 - No return type is specified because
   it will be inferred by the compiler.

 - Parameters are not surrounded by 
   parentheses().

And, what's more, we can assign a lambda 
expression to a variable and then execute it.

Creating Lambda Expressions
Let's now see some examples of lambda 
expressions. In the code below, we created a 
lambda expression without any parameters and 
assigned it a variable message. We then 
executed the lambda expression by calling
message().

 val message = {
     println("Hey, Kotlin is really cool!")
 }

 message() // "Hey, Kotlin is really cool!"

Let's also see how to include parameters in
a lambda expression.

 val message = {
     myString: String -> println(myString)
 }

 message("I love Kotlin") // "I love Kotlin"
 message("Kotlin lambdas!:)") // "Kotlin lambdas!:)"

In the code above, we created a lambda 
expression with the parameter myString, along 
with the parameter type String. As you can 
see, in front of the parameter type, there 
is an arrow: this refers to the lambda body. 
In other words, this arrow separates the 
parameter list from the lambda body.

To make it more concise, we can completely 
ignore the parameter type (already inferred 
by the compiler).

 val message = {
     myString -> println(myString)
 } // will still compile


To have multiple parameters, we just separate 
them with a comma. And remember, we don't 
wrap the parameter list in parentheses like 
in Java.

 val addNumbers = {
         number1: Int, number2: Int ->
         println("Adding $number1 and $number2")
    
         val result = number1 + number2
         println("The result is $result")
     }
 addNumbers(1, 3)

However, note that if the parameter types 
can't be inferred, they must be specified 
explicitly (as in this example), otherwise 
the code won't compile.

 Adding 1 and 3
 The result is 4


Passing Lambdas to Functions
We can pass lambda expressions as parameters 
to functions: these are called "higher-order 
functions", because they are functions of 
functions. These kinds of functions can
accept a lambda or an anonymous function as
parameter: for example, the last() collection 
function. 

In the code below, we passed in a lambda 
expression to the last() function. (If you 
want a refresher on collections in Kotlin)
As the name says, it returns the last element
in the list.
last() accepts a lambda expression as a
parameter, and this expression in turn takes 
one argument of type String. Its function 
body serves as a predicate to search within
a subset of elements in the collection. That 
means that the lambda expression will decide 
which elements of the collection will be 
considered when looking for the last one.

 val stringList: List< String> = listOf("in", "the", "club")
 
 print(stringList.last()) // will print "club"
 
 print(stringList.last({ s: String -> s.length == 3})) // will print "the"

Let's see how to make that last line of code 
above more readable.

 stringList.last { s: String -> s.length == 3 } // will also compile and print "the"


The Kotlin compiler allows us to remove the 
function parentheses if the last argument in 
the function is a lambda expression. As you 
can observe in the code above, we were 
allowed to do this because the last and only 
argument passed to the last() function is a 
lambda expression. 

Furthermore, we can make it more concise by 
removing the parameter type.

 stringList.last { s -> s.length == 3 } // will also compile print "the"


We don't need to specify the parameter type 
explicitly, because the parameter type is 
always the same as the collection element 
type. In the code above, we're calling last
on a list collection of String objects, so 
the Kotlin compiler is smart enough to know 
that the parameter will also be a String type.

The it Argument Name
We can even simplify the lambda expression 
further again by replacing the lambda 
expression argument with the auto-generated 
default argument name it.

 stringList.last { it.length == 3 }

The it argument name was auto-generated 
because last can accept a lambda expression 
or an anonymous function (we'll get to that 
shortly) with only one argument, and its
type can be inferred by the compiler.

Local Return in Lambda 
Expressions
Let's start with an example. In the code below, 
we pass a lambda expression to the foreach()
function invoked on the intList collection.
This function will loop through the 
collection and execute the lambda on each 
element in the list. If any element is 
divisible by 2, it will stop and return from 
the lambda.

 fun surroundingFunction() {
     val intList = listOf(1, 2, 3, 4, 5)
     intList.forEach {
         if (it % 2 == 0) {
             return
         }
     }
     println("End of surroundingFunction()")
 }
 
 surroundingFunction() // nothing happened

Running the above code might not have given 
you the result you might have expected. This 
is because that return statement won't return 
from the lambda but instead from the 
containing function surroundingFunction()! 
This means that the last code statement in 
the surroundingFunction() won't execute.

 // ...
 println("End of surroundingFunction()") // This won't execute
 // ...

To fix this problem, we need to tell it 
explicitly which function to return from
by using a label or name tag.

 fun surroundingFunction() {
     val intList = listOf(1, 2, 3, 4, 5)
     intList.forEach {
         if (it % 2 == 0) {
             return@forEach
         }
    }
    println("End of surroundingFunction()") // Now, it will execute
 }

 surroundingFunction() // print "End of surroundingFunction()"

In the updated code above, we specified the 
default tag @forEach immediately after the 
return keyword inside the lambda. We have now 
instructed the compiler to return from the 
lambda instead of the containing function 
surroundingFunction(). Now the last statement 
of surroundingFunction() will execute. 

Note that we can also define our own label
or name tag.

 // ...
 intList.forEach myLabel@ {
     if (it % 2 == 0) {
        return@myLabel
 // ...

In the code above, we defined our custom 
label called myLabel@ and then specified it 
for the return keyword. The @forEachlabel 
generated by the compiler for the forEach 
function is no longer available because we 
have defined our own. 

However, this local return problem can
be solved without labels, with anonymous 
functions in Kotlin.

Examples
Area_of_rectangle

  
     HappyLearning!:) by_@boolean_maybe
Lambda Expressions in Kotlin
