Kotlin from-scratch 2 - functions

Kotlin from scratch 2
franco.lombardo@smeup.com - https://www.linkedin.com/in/francolombardo/
Functions

Last episode: the power of lambdas
val elapsedTime = measureTimeMillis {
execute(compilationUnit.main.stmts)
}
public fun measureTimeMillis(block: () -> Unit): Long {
val start = System.currentTimeMillis()
block()
return System.currentTimeMillis() - start
}

}
block()
}
This is a function (lambda expression)

What is a lambda?
A lambda is a literal of a function type
val x: Int = 5
5 is a literal of type Int
val f: (Int) -> String = { "The number is $it" }
This is a literal of type (Int) -> String
(Well, on JVM it’s an instance of Function1<Int, String>)

What is a lambda?
val x: Int = 5
val f: (Int) -> String = { "The number is $it" }
it: implicit name of a single parameter

What is a lambda?
val x: Int = 5
We can use a more explicit syntax
val f: (Int) -> String = { number: Int ->
"The number is $number"
}

What is a lambda?
val x: Int = 5
Here is the evaluation of the function (y is a String)
val f = { number: Int ->
}
val y = f(x)

What is a lambda?
val x: Int = 5
The function here is unevaluated (z is a function)
val f = { number: Int ->
}
val z = f

What is a closure?
A closure is a lambda that accesses its closure, i.e. the
variables declared in the outer scope
val x: Int = 5
val f = { "The number is $x" }
val y = f()

What is a closure?
Be careful!
Prints The number is 10
var x = 5
val f = { "The number is $x" }
x = 10
println ("${f()}")

The power of lambdas
}
block()
}

The power of lambdas
}
block()
}
Higher order function: a function that has a function parameter (or result)

val elapsedTime = measureTimeMillis ({
})
“Explicit” syntax
block()
}
It’s the last parameter of this function

val elapsedTime = measureTimeMillis () {
}
block()
}
It’s the last parameter of this function,
so we can pass it outside the parentheses.

val elapsedTime = measureTimeMillis (){
}
block()
}
Since it’s the only argument,
the parentheses can be omitted entirely:

Types of bodies
See sample project: https://github.com/f-lombardo/kotlin-from-scratch
fun openDatabase(user: String, password: String): Database? =
if ("franco" == user && "secret" == password) {
sampleDatabase()
} else {
null
}
fun openDatabase(user: String, password: String): Database? {
if ("franco" == user && "secret" == password) {
return sampleDatabase()
}
return null
}
Block body
Expression body

Named arguments
println(
openDatabase("franco", "secret")
?.findComposerByName("Giuseppe Verdi")
?.findOperaByYear(1853)
?: "No results"
)
Which is the password?

Named arguments
println(
openDatabase(user = "franco", password = "secret")
?: "No results"
)

Named arguments
println(
openDatabase(password = "secret", user = "franco")
?: "No results"
)
Different order

Named arguments
println(
openDatabase(user = "franco", "secret")
?: "No results"
)
NO! It doesn’t compile. If you start with named arguments
you should go on from there
println(
openDatabase("as400", user = "franco", password = "secret")
?: "No results"
)
OK

Composing null returning functions
println(
openDatabase("franco","secret")
?: "No results"
)
fun Database.findComposerByName(name: String): Composer? =
this.composers.firstOrNull { it.name == name }
Extension function: we extend the Database class with a new method

println(
?: "No results"
)
fun Database.findComposerByName(name: String): Composer? =
this.composers.firstOrNull { it.name == name }
Composer? → {Composer U null} (sum type)
findComposerByName is “total”
i.e. it maps each input value in one output value

println(
?: "No results"
)
“or else”
“and then”
Total functions (not throwing exceptions) compose easily

Could we have a better composition?
println(
?: "No results"
)

“Good” functions compose easily
inline fun Database.findComposerBy(predicate: (Composer) -> Boolean) =
this.composers.firstOrNull(predicate)
fun similarName(name: String): (Composer) -> Boolean =
{ it.name.contains(name, ignoreCase = true) }
fun exactName(name: String): (Composer) -> Boolean =
{ it.name == name }
These functions have another function as a result
Higher order function

println(
?.findComposerBy(similarName("verdi"))
?: "No results"
)
println(
?.findComposerBy(exactName("Giuseppe Verdi"))
?: "No results"
)

println(
?.findComposerBy(exactMatchToGiacomoPuccini)
?: "No results"
)
val exactMatchToGiacomoPuccini =
exactName("Giacomo Puccini")
Functions can be stored in variables

fun exactMatchToGiuseppeVerdi(composer: Composer): Boolean =
composer.name == "Giuseppe Verdi"
println(
?.findComposerBy(::exactMatchToGiuseppeVerdi)
?: "No results"
)
Passing a function as a parameter using its name

You can use functions from the standard library too
.run(::println)

Extension function applicable to objects of any type:
it passes the object to the given function
.run(::println)

Not that good: prints null if no result is found
.run(::println)

fun Opera?.displayResult(): Unit =
if (this == null) {
println("No result")
} else {
println(this)
}
.run(::displayResult)

if (this == null) {
} else {
println(this)
}
Extension function on a nullable type

if (this == null) {
} else {
println(this)
}
if statements are also expressions.
(The result here has type Unit)

Infix methods
infix fun Opera?.displayResultTo(printStream: PrintStream): Unit =
if (this == null) {
printStream.println("No result")
} else {
printStream.println(this)
}
?.findOperaByYear(1901) displayResultTo System.err

println(
?.operas
?.maxBy (Opera::yearOfComposition)
?: "No results"
)
Functional API for collections (like map, sortBy, find…)
They get function parameters
A List

println(
?.operas
?.maxBy (Opera::yearOfComposition)
?: "No results"
)
Member reference: it’s like a lambda that has the object
as a parameter and invokes the method on it
A List

More functional APIs for collections
println(
?.operas
?.sortedBy (Opera::yearOfComposition)
?.map (Opera::name)
?: "No results"
)
sortedBy doesn’t sort the original collection,
but it returns a sorted copy of it: immutable data!

Constructors are functions
class OperaHtmlDiv(val opera: Opera) {
override fun toString(): String =
"<div>${opera.name} ${opera.yearOfComposition}</div>"
}
println(
?.operas
?.sortedBy (Opera::yearOfComposition)
?.map (::OperaHtmlDiv)
?: "No results"
)
We pass a constructor as a parameter

Do we really need all these checks?
println(
?.run {
operas
.sortedBy(Opera::yearOfComposition)
.map(::OperaHtmlDiv)
}
?: "No results"
)
Implicit this

The dark side of lambdas
fun Database.findComposerBy(predicate: (Composer) -> Boolean) =
A new object is created here
?.findComposerBy {
it.name.toLowerCase().startsWith("v")
}

The dark side of lambdas
inline fun Database.findComposerBy(predicate: (Composer) -> Boolean) =
Inlining the function the compiler doesn’t need a new object
?.findComposerBy {
it.name.toLowerCase().startsWith("v")
}
See https://www.baeldung.com/kotlin-inline-functions
• Use Inline with functions that have a lambda parameter
• With inline we can’t pass the lambda around,
so it can’t be the result of our higher order function

What is a “good” function?
• It is total, i.e. it maps each input value in one output value
(no exceptions)
• It works with immutable data types
(it doesn’t modify its parameters)
• It does not cause any observable side effects
• It returns the same result if given the same arguments
(it doesn’t depend on the environment)
• So it is referentially transparent, i.e. it can be replaced with its
corresponding value without changing the program's
behaviour

Good reads
Kotlin weekly
Great weekly newsletter: http://www.kotlinweekly.net/
Uberto Barbini on Medium
https://medium.com/@ramtop
Kotlin expertise blog by Simon Wirtz
https://kotlinexpertise.com/
Florina Muntenescu on Medium
https://medium.com/@florina.muntenescu
Kotlin blog by JetBrains
https://blog.jetbrains.com/kotlin/

Kotlin from-scratch 2 - functions

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Kotlin from-scratch 2 - functions

Similaire à Kotlin from-scratch 2 - functions (20)

Plus de Franco Lombardo

Plus de Franco Lombardo (15)

Dernier

Dernier (20)

Kotlin from-scratch 2 - functions