Kotlin lambda expressions_20210608

Lambda Expressions
Haim Michael
June 8th
, 2021
All logos, trade marks and brand names used in this presentation belong
to the respective owners.
life
michae
l
www.lifemichael.com
in
Kotlin

© 2008 Haim Michael 20150805
XtremePython Conference
https://xtremepython.dev
This Conference will be in English

© 2008 Haim Michael 20150805
XtremeJS Conference
https://xtremejs.dev
This Conference will be in English

© 2008 Haim Michael 20150805
Courses on Udemy
https://www.udemy.com/user/life-michael/
Online Courses in English

© 2008 Haim Michael 20150805
Online Courses
Https://academy.lifemichael.com
Online Courses in English and in Hebrew

© 2008 Haim Michael 20150805
Online Courses for Kids
http://kids.lifemichael.com
Online Courses in English and in Hebrew

© 2008 Haim Michael 20150805
Premium Training Services
https://lifemichael.com
Professional Services in English and in Hebrew

© 2008 Haim Michael 20150805
Scala Fundamentals Course
http://scala.course.lifemichael.com
This Course is delivered in Hebrew

© 2008 Haim Michael 20150805
Kotlin Fundamentals Course
http://kotlin.course.lifemichael.com
This Course is delivered in Hebrew

© 2008 Haim Michael 20150805
Functional Programming in Java
http://functional.java.seminar.lifemichael.com/
This Seminar is delivered in Hebrew

© 2008 Haim Michael 20150805
Table of Contents
 We are going to cover the following topics:
Introduction to Lambda
Higher Order Functions
Function Types in Kotlin
The Parameters' Names
Combining Function Types
Instantiating Function Types
Compiler Inference
Invoking Function Type Objects
Function Literals
Lambda Expressions Syntax
The Function Last Parameter
The it Implicit Parameter
The :: Operator
The Underscore Style

© 2009 Haim Michael All Rights Reserved 3.1.2021 12
Introduction
 The functions in Kotlin can be first class, which means that
we can handle objects that represent functionality. We can
store the references for those object into variables, pass the
references as arguments to other functions or get them as
the returned value when calling a function.

Higher Order Functions
 Higher order function is a function that takes functions as
arguments and/or returns a function.

Function Types
 Kotlin uses a family of function types for declarations that
deal with functions.
val onLoad: () → Unit = …
 The function type has a parenthesized parameter types list
and a return type:
(A,B) -> C

Function Types
 The function type can optionally have an additional receiver
type, specified before a dot.
A.(B) -> C
This type represents a function we can invoke on object of
type A, with parameter of type B, and a returned value of
type C.

Function Types
 Using the suspend modifier we can indicate the function is
a suspending one.
suspend () -> Unit
suspend A.(B) -> C
 Suspending functions can be called from within coroutines
only.

Function Types
 In order to specify a function type is nullable we should
place it all in parentheses and add the question mark.
((Int,Int)->Int)?
 We can give a function type an alternative alias by using the
typealias keyword.
typealias Calculate = (Int,Int) ->Int

Parameters Names
 The function type notation can include names for the
parameters. Using such names assists with the creation of
accurate documentation.
(height:Int, width:Int) -> Rectangle

Combining Function Types
 It is possible to combine function types and use parentheses
in order to get code that is easier to understand.
(Int) -> ((int)->Unit)
 The arrow notation is right associative, which enables us to
write alternatively the following:
(Int) -> (Int) -> Unit
`

Instantiate Function Type
 There are several ways for instantiating a function type. We
can do it using a lambda expression.
{a,b -> a+b}
 We can do it using an anonymous function.
fun(s:String):Int {return s.length}

 We can declare a class that implement a specific function
type as an interface.
 We can assign a function type variable with a reference for
an object we instantiate from that class.

class X : (Int) -> Int {
override fun invoke(x:Int):Int = 10*x
}
var f = X()
fun main(args: Array<String>) {
print(f(4))
}

Compiler Inference
 The compiler can infer the function types of variable when
enough information is available.
val f = {num:Int -> num + 1}

Function Type with Receivers
 The values of function types with and without receiver are
interchangeable. The receiver can stand for the first
parameter.
var f1:String.(Int)->String = {num -> this.repeat(num)}
var f2:(String,Int)->String = f1

Invoking Function Type Instances
 We can invoke it either using the invoke(...) method or
just by using simple parentheses.
class X : (Int) -> Int {
override fun invoke(x:Int):Int = 10*x
}
var f = X()
fun main(args: Array<String>) {
print(f(4))
print(f.invoke(4))
}

Function Literals
 Lambda expressions and anonymous functions are
considered as function literals.
 Functions literal are functions that are not declared and can
be passed over.
max (numbers, {a,b->a<b})

 The full syntactic form of a lambda expression includes the
use of the curly braces. The lambda expression is always
surrounded by curly braces.
val f = {x:Int,y:Int->x+y}

 If the return type of the lambda expression is not Unit, then
the last (or possibly single) expression inside the lambda
body is treated as the returned value.
val sum : (Int,Int)->Int = {x,y->x+y};
val sum : (Int,Int)->Int = {x,y->
var result = x + y
result
};

The Function Last Parameter
 If the last parameter of a function accepts a function, a
lambda expression that is passed over as the corresponding
argument to that parameter, can be placed outside of the
parentheses:
val ob = accounts.doSomething(0) {total,e → total *e}

The it Implicit Parameter
 When the lambda expression has one parameter only, it is
allows to omit the arrow and implicitly name the parameter
with it.
numbers.filter(it%2==0)

The :: Operator
 When prepending a function name with the '::' operator we
will get a reference for the object that represents the
function.
 We can then assign that referent to a variable that its type is
a function type.
fun add(a: Int, b: Int) = a + b
var f: (n1:Int,n2:Int)->Int = ::add
println(f(3,4)) //prints 7

The Underscore Style
 When writing a lambda expression and having a parameter
we don't use we can place an underscore instead.
map.forEach {_,v -> println(“$v is awesome!“}

Kotlin lambda expressions_20210608

More Related Content

More from Haim Michael

Recently uploaded

Kotlin lambda expressions_20210608