D
Appendix D: Chapter 4 Exercise & Challenge Solutions
Written by Massimo Carli
Heads up... You're reading this book for free, with parts of this chapter shown beyond this point as
text.You can unlock the rest of this book, and our entire catalogue of books and videos, with a raywenderlich.com Professional subscription.
Exercise 4.1
Can you write a lambda expression that calculates the distance between two points given their coordinates, x1, y1
and x2, y2
? The formula for the distance between two points is distance = √(x2−x1)²+(y2−y1)²
.
Exercise 4.1 solution
You can approach this problem in different ways. Assuming you pass all the coordinates as distinct parameters, you can write the following code:
val distanceLambda = { x1: Double, y1: Double, x2: Double, y2: Double -> // 1
val sqr1 = (x2 - x1) * (x2 - x1) // 2
val sqr2 = (y2 - y1) * (y2 - y1) // 2
Math.sqrt(sqr1 + sqr2) // 3
}
typealias Point = Pair<Double, Double>
val distanceLambdaWithPairs = { p1: Point, p2: Point ->
val sqr1 = Math.pow(p1.first - p2.first, 2.0)
val sqr2 = Math.pow(p1.second - p2.second, 2.0)
Math.sqrt(sqr1 + sqr2)
}
fun main() {
println(distanceLambda(0.0, 0.0, 1.0, 1.0))
println(distanceLambdaWithPairs(0.0 to 0.0, 1.0 to 1.0))
}
1.4142135623730951
1.4142135623730951
Exercise 4.2
What’s the type for the lambda expression you wrote in Exercise 4.1?
Exercise 4.2 solution
The type of distanceLambda
is:
val distanceLambda: (Double, Double, Double, Double) -> Double
val distanceLambdaWithPairs: (Point, Point) -> Double
val distanceLambdaWithPairs: (Pair<Double, Double>, Pair<Double, Double>) -> Double
Exercise 4.3
What are the types of the following lambda expressions?
val emptyLambda = {} // 1
val helloWorldLambda = { "Hello World!" } // 2
val helloLambda = { name: String -> "Hello $name!" } // 3
val nothingLambda = { TODO("Do exercise 4.3!") } // 4
typealias AbsurdType = (Nothing) -> Nothing
Exercise 4.3 solution
You start by looking at:
val emptyLambda = {}
val emptyLambda: () -> Unit
val helloWorldLambda = { "Hello World!" }
val helloWorldLambda: () -> String
val helloLambda = { name: String -> "Hello $name!" }
val helloLambda: (String) -> String
val nothingLambda = { TODO("Do exercise 4.3!") }
val nothingLambda: () -> Nothing
Nothing and lambda
Given the type:
typealias AbsurdType = (Nothing) -> Nothing
val absurd: AbsurdType = { nothing -> throw Exception("This is Absurd") }
fun main() {
absurd(TODO("Invoked?"))
}
fun main() {
absurd(throw Exception("Invoked?"))
}
Exercise 4.4
Can you implement a function simulating the short-circuit and operator with the following signature without using &&
? In other words, can you replicate the short-circuiting behavior of left && right
:
fun shortCircuitAnd(left: () -> Boolean, right: () -> Boolean): Boolean
Exercise 4.4 solution
In Kotlin, if
is an expression, so you can implement shortCircuitAnd
like this:
fun shortCircuitAnd(
left: () -> Boolean,
right: () -> Boolean
): Boolean = if (left()) {
right()
} else {
false
}
fun main() {
val inputValue = 2
shortCircuitAnd(
left = { println("LeftEvaluated!"); inputValue > 3 },
right = { println("RightEvaluated!"); inputValue < 10 },
)
}
LeftEvaluated!
LeftEvaluated!
RightEvaluated!
Exercise 4.5
Can you implement the function myLazy
with the following signature, which allows you to pass in a lambda expression and execute it just once?
fun <A: Any> myLazy(fn: () -> A): () -> A // ???
Exercise 4.5 solution
myLazy
accepts a lambda expression of type () -> A
as an input parameter. It’s also important to note that A
has a constraint, which makes it non-null. This makes the exercise a little bit easier, because you can write something like:
fun <A : Any> myLazy(fn: () -> A): () -> A {
var result: A? = null // 1
return { // 2
if (result == null) { // 3
result = fn() // 4
}
result!! // 5
}
}
fun main() {
val myLazy = myLazy { println("I'm very lazy!"); 10 }
3.times {
println(myLazy())
}
}
I'm very lazy!
10
10
10
Exercise 4.6
Create a function fibo
returning the values of a Fibonacci sequence. Remember, every value in a Fibonacci sequence is the sum of the previous two elements. The first two elements are 0
and 1
. The first values are, then:
0 1 1 2 3 5 8 13 21 ...
Exercise 4.6 solution
The following is a possible implementation for the Fibonacci sequence using lambda evaluation:
fun fibo(): () -> Int {
var first = 0
var second = 1
var count = 0
return {
val next = when (count) {
0 -> 0
1 -> 1
else -> {
val ret = first + second
first = second
second = ret
ret
}
}
count++
next
}
}
fun main() {
val fiboSeq = fibo()
10.times {
print("${fiboSeq()} ")
}
}
0 1 1 2 3 5 8 13 21 34
Challenge 4.1
In Exercise 4.5, you created myLazy
, which allowed you to implement memoization for a generic lambda expression of type ()-> A
. Can you now create myNullableLazy
supporting optional types with the following signature?
fun <A> myNullableLazy(fn: () -> A?): () -> A? // ...
Challenge 4.1 solution
To remove the constraint, you just need to use an additional variable, like this:
fun <A> myNullableLazy(fn: () -> A?): () -> A? {
var evaluated = false // HERE
var result: A? = null
return { ->
if (!evaluated) {
evaluated = true
result = fn()
}
result
}
}
fun main() {
val myNullableLazy: () -> Int? =
myNullableLazy { println("I'm nullable lazy!"); null }
3.times {
println(myNullableLazy())
}
}
I'm nullable lazy!
null
null
null
Challenge 4.2
You might be aware of Euler’s number e. It’s a mathematical constant of huge importance that you can calculate in very different ways. It’s an irrational number like pi that can’t be represented in the form n/m
. Here you’re not required to know what it is, but you can use the following formula:
Challenge 4.2 solution
A possible implementation of the Euler formula is:
fun e(): () -> Double {
var currentSum = 1.0 // 1
var n = 1
tailrec fun factorial(n: Int, tmp: Int): Int = // 2
if (n == 1) tmp else factorial(n - 1, n * tmp)
return {
currentSum += 1.0 / factorial(n++, 1).toDouble() // 3
currentSum
}
}
fun main() {
val e = e()
10.times {
println(e())
}
}
2.0
2.5
2.6666666666666665
2.708333333333333
2.7166666666666663
2.7180555555555554
2.7182539682539684
2.71827876984127
2.7182815255731922
2.7182818011463845
fun factSeq(): () -> Int {
var partial = 1
var n = 1
return {
partial *= n++
partial
}
}
fun fastE(): () -> Double {
var currentSum = 1.0
val fact = factSeq()
return {
currentSum += 1.0 / fact().toDouble()
currentSum
}
}
fun main() {
val e = fastE() // HERE
10.times {
println(e())
}
}
2.0
2.5
2.6666666666666665
2.708333333333333
2.7166666666666663
2.7180555555555554
2.7182539682539684
2.71827876984127
2.7182815255731922
2.7182818011463845