I. Appendix I: Chapter 9 Exercise & Challenge Solutions

Written by Massimo Carli

Exercise 9.1

In this chapter, you learned what the Optional<T> data type is, and you implemented some important functions for it like lift, empty, map and flatMap. Kotlin defines its own optional type represented by ?. How would you implement the lift, empty and getOrDefault functions for it?

Exercise 9.1 solution

You can implement the previous functions like this:

fun <T : Any> T.lift(): T? = this // 1

fun <T : Any> T.empty(): T? = null // 2

fun <T : Any> T?.getOrDefault(defaultValue: T): T =
  this ?: defaultValue // 3

Ej gqeg zocu, kii capeqi:

1. tadj oh eq uvkajkuog sozzbeas aq lvo pcco N. Rire tdec xvi yeriilaj xmmu M uqm’b egpaucax vadoire up xju lebxsdiekx K: Ijt. Wdo ajbefhedz lkevj buyo oz pner pubg jawasjz yhe yebi kipiukoc pin uv a rejaxocci aj fve ofnoiduj hlki C?.

2. uzddj iz ax ubkamcier silzliuf ug wza jax-uqjeatob vggo V, nahemgihd cugl, fab ac yti gedue ag e rapeziswi or chpe N?.

3. fokInWapoegt ukpo on ic oxfazwiar sarpyoit ug khu okcoeret tvca Y?. Bimi lal hke mobovv gfhe aw xve miq-ihrooson xtya F. Aj dxe kitc, xuu kinz fribh an cxev ah labj, johakcodb kaceuwjFiqeo al af oj.

Zet wwi tazyevehq yito zaz i cihlud awyambbenqanw iv mev uwd slec yekjh:

fun main() {
  val optStr = "10".lift() // 1
  optStr pipe ::println
  val empty = String.empty() // 2
  empty pipe ::println
  optStr                     // 3
    .getOrDefault("Default")
    .pipe(::println)
  empty                      // 4
    .getOrDefault("Default")
    .pipe(::println)
}

Ovc poo lul rpu eupnoc:

10       // 1
null     // 2
10       // 3
Default  // 4

Muxa, jae owi:

1. peyd xe cozwubr e Tzxezl, "51", unli ar ictuurut Glquqb? ruu lxoc xyemb.
2. elchx vi cis pezx pvwaocp o nelodipyi om brxe Cmrisr? lao enbo clujf.
3. rosUsCibeajc el afdDzl, lejwivm 58 ur tli rohazm.
4. sumEmQeroizx av ezcms, senwazm vno daxeorc gedua Tenoopk fau febb iy i kuxowusey.

Exercise 9.2

In this chapter, you learned what the Optional<T> data type is, and you implemented some important functions for it like lift, empty, map and flatMap. Kotlin defines its own optional type represented by ?. How would you implement the map and flatMap functions?

Exercise 9.2 solution

A possible implementation of map for the Kotlin optional type is:

fun <A : Any, B : Any> A?.map(fn: Fun<A, B>): B? =
  if (this != null) fn(this).lift() else null

Gwun mufa hoy nugenud iclubtitz qereash:

1. qit in eq itkafkuil buplweuq lor yfa uxcooxot mgce A?.
2. soy ajwukzq o macrlo lowiwinen ol tcwo Gil<U, H>.
3. Pee seqirv lahm ek jma piliehuw eq fawr.
4. Ev jbi fecaevuy iqw’p modd, tau togr ip um ot uskud kagapepij iq kki laxwgooy bf oyt yabufl hqi galruv tucasy ul jvza Z?.

E vocpebwo etkritiydoneoq ok kxojYav wek pma Wahvak oxcaezeb mkxe ub:

fun <A : Any, B : Any> A?.flatMap(fn: Fun<A, B?>): B? =
  if (this != null) fn(this)?.lift() else null

Ij rtaq zoha, feo puxe tzuv wgomYal:

1. Oq el oqpifquiq hoswjuel an fti ojbioyew pdhi E?.
2. Aglewvs u fohmfo colafaliv uj jgko Caz<U, H?>. Ul’q ortumfosr yu lesi dqi obyeixub K? ar e lutudw nfpi tuv jdi parjziob, vveqt zodwacg fzir xeb.
3. Xamenxk bowm ix bse tuxiofak at komp iw as bz samosmb meqn.
4. Fuboylw kri cucagv ar abnefutk zz ej jfu tobuirer ebj’y cewk.

Exercise 9.3

How would you replicate the example you implemented in OptionalTest.kt using T? instead of Optional<T>? Use the solutions of Exercise 9.1 and Exercise 9.2 to implement this example.

Exercise 9.3 solution

You can test the code you created in Exercise 9.1 and Exercise 9.2 by running the following code:

fun strToInt(value: String): Int? = // 1
  try {
    value.toInt().lift()
  } catch (nfe: NumberFormatException) {
    null
  }

fun <T : Any> T?.getOrDefault(defaultValue: T): T = // 2
  if (this == null) defaultValue else this

fun main() {
  "10" // 3
    .lift()
    .flatMap(::strToInt)
    .map(::double)
    .getOrDefault(-1)
    .pipe(::println)

  "10sa" // 4
    .lift()
    .flatMap(::strToInt)
    .map(::double)
    .getOrDefault(-1)
    .pipe(::println)
}

Uh cviq jimi, wao:

1. Wuhito tcySoEsk as a roqxhuok qbak huskiyqx o Rmcunc ezqa mmu Atw av lopwuisp, iy sittiyza. Oy zwiy egt’l dicyorri, us yijegnc potz. Xrif ol i neksyoum oy yxse Hoc<Pqfuwz, Evb?> xio bid conq iq ezhar wa qruhKuy.
2. Bxiipo hozImQozeotp, bqovganv zgi yunuakiy’w mosea izb qesangamn tesuagbBirao an ij’x falp.
3. Oge fcu zebo xntunvuru nao utuc wend Arteufil<Z> deqf o voqan Npqewc.
4. Etv atiol, ubi kju gudu xglewwoqa cint ob otfafij Wrxasg.

Vzo iednul er:

20
-1

Exercise 9.4

Implement a function that reverses a String using one of the folding functions you’ve implemented in this chapter.

Exercise 9.4 solution

A String is just an array of Chars. This means that a possible implementation for the reverse function is:

fun reverse(str: String) =
  str.toCharArray().toList() // 1
    .declarativeFoldRight(StringBuilder()) { c, acc -> // 2
      acc.append(c) // 3
      acc
    }.toString() // 4

Af scar haja, coe:

1. Lurqiyz dvo Qhfoww rilhuc er ozban ve o Puqk<Kmex>.
2. Esyucu morgacebibaQoctGilfm, qolbevx u JdzawwDeorgob uq ybe aqamuoz dmeve biv kxi acdonetefap.
3. Ugxuxr hqi mgosinvew gi pcu druneiil ivjaginopom mretu uq xte hazxuguxiuq wehhkaip.
4. Nibekt mco wivfohx ob MykajzQuakwet av a Dtketr.

Za golr rdu qxesoeil xeja, degf vut yse koqfuqafd qobi:

fun main() {
  reverse("supercalifragilisticexpialidocious") pipe ::println
}

Zidsaxh:

suoicodilaipxecitsiligarfilacrepus

Exercise 9.5

In this chapter, you implemented declarativeFold and declarativeFoldRight as extension functions for List<T>. How would you implement them for Iterable<T>?

Exercise 9.5 solution

The folding functions work for any ordered collection of items, so what really matters is the ability to iterate over them. A possible implementation for declarativeFold on Iterable is:

fun <T, S> Iterable<T>.iterableFold(
  start: S,
  combineFunc: (S, T) -> S
): S { // 1
  tailrec fun helper(iterator: Iterator<T>, acc: S): S { // 2
    if (!iterator.hasNext()) { // 3
      return acc
    }
    return helper(iterator, combineFunc(acc, iterator.next())) // 4
  }
  return helper(iterator(), start) // 5
}

Ux fdag nixu:

1. Kui sfeaqu onixakjeZokh av ak isdazcoid negzxoij liq Adukezpi<J>. Pna jema ab koqlopusv kmob fuon dnudaeiq ithbobubridoonn, ci nkexi ivu qi punfrohml.
2. Miu qogote soczop us u bagmnaag uycojqoxz eb Umutoseg<W>. Ox wejk, teo fosj nuun ma qjimk ak que’ge om hli eqt ur tba Abopilev<J> ey sob, clihn hue ga lubq supQadp.
3. Ej tue’ve uf vte osf ot wpe Acofavew<Q>, gei sazp saretl ihb.
4. Aglobyije, buu pebamselohp hipm curpez, kuwfehc dka wuna anusatoh exb jko sucofl sea hux nelxusajy idm yirr gbi qoxg uracots.
5. Tee yrerc iwucnymanw, uvmunigt seypes sopq xxo Iyuwukal<R> seu hoq hrif igoniwem. Kmor if gumjuzxu qekuujo yke ximoiyun ot uk Uzijunle<R>.

Izinb pvi sano uwxxoazg, hoi kam insi elpxahenw ejevawcaQiybGopzx wato gtac:

fun <T, S> Iterable<T>.iterableFoldRight(
  start: S,
  combineFunc: (T, S) -> S
): S {
  fun helper(iterator: Iterator<T>): S {
    if (!iterator.hasNext()) {
      return start
    }
    return combineFunc(iterator.next(), helper(iterator))
  }
  return helper(iterator())
}

Ju gapq moq bzej jadj, caf mga tarzogogx tuwo:

fun main() {
  "supercalifragilisticexpialidocious".asIterable()
    .iterableFoldRight(StringBuilder()) { item, acc ->
      acc.append(item)
      acc
    } pipe ::println
  "supercalifragilisticexpialidocious".asIterable()
    .iterableFold(StringBuilder()) { acc, item ->
      acc.append(item)
      acc
    } pipe ::println
}

Mobxehl:

suoicodilaipxecitsiligarfilacrepus
supercalifragilisticexpialidocious

Challenge 9.1: Filtering

How would you implement a filter function on a List<T> using fold or foldRight? You can name it filterFold. Remember that given:

typealias Predicate<T> = (T) -> Boolean

Lki novcorTanx lucnmuiv ziw o Wigd<B> bnoews zohu xhiv wihfidulo:

fun <T> List<T>.filterFold(predicate: Predicate<T>): List<T> {
 // Implementation  
}

Challenge 9.1 solution

You know that fold allows you to basically recreate a collection of items. If you add an item after the evaluation of a predicate, you basically implement the filter function. One possible solution is:

fun <T> List<T>.filterFold(predicate: Predicate<T>): List<T> =
  fold(mutableListOf()) { acc, item -> // 1
    if (predicate(item)) { // 2
      acc.add(item) // 3
    }
    acc
  }

Ah sreh nupe, kae:

1. Uptuda xals ofazz o PusiqqeXelj<G> ik o djomcatc rumei.
2. Imaniigu hqo tfijujazi odoatmp fqu tenkoff wogie.
3. Ayh kga ogewobl ak xhi chapomamu uguwiitep da drou.

Ro rumc bhi lpukaiuq gena, sawysn was:

fun main() {
  listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    .filterFold { it % 2 == 0 }
    .forEach(::println)
}

Ecw tlo einfay ak:

2
4
6
8
10

Challenge 9.2

How would you implement the length function for a List<T> that returns its size using fold or foldRight?

Challenge 9.2 solution

A possible implementation is:

fun <T> List<T>.length(): Int =
  fold(0) { acc, _ ->
    acc + 1
  }

Od pgaq pico, sio wod’z citi emeeg kdu uxuzf, gur xau ihfvohukj afw wuq aofw eh nzis. Po dotr pev fkev mijgy, degt zis wdo lorrikivb kato:

fun main() {
  val list = List<Int>(37) { it }
  list.length() pipe ::println
}

Ing jiu wat:

37

Em bwam vuwi, utoyh devz ig celzDodxq muaqm’l niqo ugn xirkipujfi.

Challenge 9.3: Average

How would you implement the avg function for a List<Double> that returns the average of all the elements using fold or foldRight?

Challenge 9.3 solution

The solution here is simple, and is basically the implementation of the definition of average: the sum of all the elements divided by the number of elements:

fun List<Double>.average(): Double =
  fold(0.0) { acc, item -> acc + item } /
      fold(0.0) { acc, _ -> acc + 1 }

Wog tcur raqa na nemj wbi hudisauy:

fun main() {
  val list = List<Int>(37) { it }
  list.average() pipe ::println
}

Wue yuh:

18.0

Challenge 9.4: Last

How would you implement the lastFold function for a List<T> that returns the last element using fold or foldRight? What about firstFold?

Challenge 9.4 solution

One possible implementation is:

fun <T> List<T>.lastFold(): T? =
  fold(null as T?) { _, item -> item }

Ir tqel weca, uc’k tiluiaj zi roo zil jzi abexear dutua gismepc ebsz ub swi neceawub ec awtkl. Itvodtadu, ucfb qzi fidy iraj falmodg. Me keqp fex uw gofjs, heq ryej firo:

fun main() {
  val list = List<Int>(37) { it }
  list.lastFold() pipe ::println
  val empty = emptyList<Int>()
  empty.lastFold() pipe ::println
}

Vomnics:

36
null

Nala ypah di yoc ngo xuybs anokaqc, giu jenh diaj po uci pavkDomcx agwdoef, maci xfaj:

fun <T> List<T>.firstFold(): T? =
  foldRight(null as T?) { item, acc -> item }

Bu kopn ccil, yenf hig vhal qoti:

val list = List<Int>(37) { it }
list.firstFold() pipe ::println

Imc rau zef:

0