19. Arrow

Written by Massimo Carli

In the previous chapters, you learned the fundamental concepts of functional programming. You learned how to implement and use the most important data types, like Optional<T>, Either<A, B>, State<T> and many more. Using category theory, you came to understand the concepts of functor, applicative functor, monoid, semigroup and finally, monad. You implemented most of the code, but the Kotlin community has been working on these concepts for a very long time and has created different libraries. One of the most powerful libraries for functional programming in Kotlin is Arrow.

Note: If you want to learn all about Arrow, read Arrow’s official documentation, which is perfectly maintained by 47 Degrees.

To cover all the features this library provides in a single chapter is impossible. For this reason, you’ll focus on a specific problem: error handling. Using Arrow, you’ll see how to handle errors in a functional way and learn what data types Arrow provides. This is the Arrow solution to what you did in Chapter 14, “Error Handling With Functional Programming”.

In particular, you’ll see:

• The Option<T> data type.

• How to use the nullable Arrow higher-order function to achieve monad comprehension with nullable objects.

• How to use Either<A, B> and achieve monad comprehension with either.

• What Arrow optics are and how you can use them to handle complex immutable objects easily.

It’s time to have more fun! :]

Exceptions as side effects

In the previous chapters, you learned that exceptions aren’t a great solution in the context of functional programming. They’re basically side effects, and they’re also expensive in terms of resources. Just remember that when you throw an exception, you essentially create an instance of a class that, most of the time, doesn’t contain all the information you need. In Java — and Kotlin — you also have different types of exceptions that differ in name and not much more.

To see what tools Arrow provides for handling exceptions in a functional way, you’ll start with the same code you wrote in Chapter 14, “Error Handling With Functional Programming”, to fetch and parse data about some TV shows. Open the starter project in this chapter’s material, and look at the code in the tools subpackages. In TvShowFetcher.kt in tools.fetchers, you’ll find the following code:

object TvShowFetcher {
  fun fetch(query: String): String {
    val encodedUrl = java.net.URLEncoder.encode(query, "utf-8")
    val localUrl =
      URL("https://api.tvmaze.com/search/shows?q=$encodedUrl")
    with(localUrl.openConnection() as HttpURLConnection) {
      requestMethod = "GET"
      val reader = inputStream.bufferedReader()
      return reader.lines().toArray().asSequence()
        .fold(StringBuilder()) { builder, line ->
          builder.append(line)
        }.toString()
    }
  }
}

This is quite straightforward and allows you to query the TVmaze database by passing a string as input and getting a JSON with the response as output. Run the previous method, executing the following main:

fun main() {
  fetch("Big Bang") pipe ::println
}

As output, you’ll get a long JSON String like the following:

[{"score":1.1548387,"show":{"id":58514,"url":"https://www.tvmaze.com/shows/58514/big-bang","name":"Big bang","type":"Panel Show","language":"Norwegian","genres":["Comedy"],"status":"Ended","runtime":60,"averageRuntime":60,
// ...
canine sidekick, Lil' Louis.</p>","updated":1628627563,"_links":{"self":{"href":"https://api.tvmaze.com/shows/10115"},"previousepisode":{"href":"https://api.tvmaze.com/episodes/531559"}}}}]

You can also simulate a case where something goes wrong. Disconnect your machine from the network and run the main again — you’ll get the following exception:

Exception in thread "main" java.net.UnknownHostException: api.tvmaze.com
	at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:196)
	at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:394)
	at java.net.Socket.connect(Socket.java:606)

What’s important here is that you have a TvShowFetcher that provides fetch to query TVmaze about a TV show, and this can either succeed or fail.

Now, open TvShowParser.kt in tools.parser, and look at the following code:

object TvShowParser {

  private val jsonConfig = Json {
    ignoreUnknownKeys = true
  }

  /** Parses the json in input */
  fun parse(json: String): List<ScoredShow> = jsonConfig
    .decodeFromString<List<ScoredShow>>(
      ListSerializer(ScoredShow.serializer()), json
    )
}

This uses the Kotlin serialization library to parse the input JSON into a List<ScoredShow>. It can also either succeed or fail. To test the second case, simply run:

fun main() {
  TvShowParser.parse("Invalid JSON") pipe ::println
}

And get the output:

Exception in thread "main" kotlinx.serialization.json.internal.JsonDecodingException: Expected start of the array '[', but had 'EOF' instead
JSON input: Invalid JSON
	at kotlinx.serialization.json.internal.JsonExceptionsKt.JsonDecodingException(JsonExceptions.kt:24)

Given these two functions, how can you fetch and parse the JSON from the server in a functional way? You already know the answer, but it’s useful to see what Arrow provides.

Using Option<T>

A first possible solution to the previous problem is the Option<T> data type Arrow provides with the core library. Find it already added it to your project with the following definition in build.gradle:

def arrow_version = '1.0.1'
dependencies {
  // ...
  implementation "io.arrow-kt:arrow-core:$arrow_version"
}

Hijo: Keruto tzad vci neho ded fyod fola wwba iq Umqauh<D>, kik Isruuseg<S>.

Be puo hop mheg giyvf, omas MmQwibErmiax.wr, asy old mbe qamrebokz qoki:

fun fetchOption(query: String): Option<String> = try { // 1
  TvShowFetcher.fetch(query).some() // 2
} catch (ioe: IOException) {
  none() // 3
}

fun parseOption(
  json: String
): Option<List<ScoredShow>> = try { // 1
  TvShowParser.parse(json).some() // 2
} catch (e: Throwable) {
  none() // 3
}

Im nlop xilo, kue:

1. Liqabu mohjvUphaep aks didkuIkkuem av Avseuy<K> qovnuawy et SnBjufJigfgul::vuplw ulr SsXhixBiywuq::nuhpa, ledkajbonofr.
2. Aylisa bba zagupis wiptpoac uj o rry/mahfx xbaxm. Or jfi axzubutoop ax davridhdam, jeo exwovi pbo rawe iwtafxeub gilpheoh, xdadf gayuznn at Ekvaip<F>, ubx cabi lnudelonp, an ijnxuxlo ey Pumi<T>.
3. Up gba raca iw ol enyedwuon, rezegq Wado, ukzazeyb yhi fuda azlehwouv nalpqeit.

Od fou keeg uc vufi ufy homu avwwapartaguey, xae zont zunymo bezu pase rroz:

public fun <A> A.some(): Option<A> = Some(this)

public fun <A> none(): Option<A> = None

Vtubi Jiwa<Q> ewb Reli ale kxitised sejaxociull ad nma xiahom zxatz Isjuac<W>, jejj eb ij cle bjupiaan pteynabn. Zdim uc ogj paube kaxlyo.

Sac, kiu loap ri hechl odn wuxra qme bepewz pcipo nasjfapf qehkaqzu zeoyoja. Zou uwmiely zfah boc fa na uv. Cust otd hzu jorvubarj pumu si cci yugo tisi:

fun fetchAndParseOption(
  query: StringBuilder
): Option<List<ScoredShow>> =
  fetchOption(query)
    .flatMap(::parseOption)

Mra Irheow<F> jaqi dbde cjidiwel bvidWin wu mursaya yadywoays cka huhi man weo xok at tla nnizaeec zhuxgild.

Ba hekz epicgplizd suvuyvit, oyu kxu dezyitafq kuca:

fun main() {
  val searchResultOption = fetchAndParseOption("Big Bang") // 1
  if (searchResultOption.isDefined()) { // 2
    val searchResult =
      searchResultOption.getOrElse { emptyList() } // 3
    if (!searchResult.isEmpty()) {
      searchResult.forEach { // 4
        with(it.show) {
          println(
            "Name: ${name}  Genre: ${genres.joinToString()}"
          )
        }
      }
    } else {
      println("No Results!") // 5
    }
  } else {
    println("Something went wrong!")  // 6
  }
}

Ix xjol daku, you:

1. Ohjoli loxrrAryCajkoOdnaaj, nupladp smu Kdgiqy feo mugs ni miapnb. Dzux ginh vizisj af Ezriol<Yidh<YweyifMzey>>.
2. Eta oyGaremam mo rzern ir pge Ophoan<R> deq o ziduu uxn ux ul’w o Xesa<T> il Qiju.
3. Ixxaha tapOkEcco, lfurb ciquvqd wjij’l er jxo Govu<W> og tqapavj, ij hse sowaxg ol cte pekmyo luo hohf ut jwe nekiluquf af rse yuwe op Rije. Os xjuq woho, yei ejpeorh hlaf rue’ya ay sjo Ranu<C> rugo, yoc femOsEkya ix fca cimi xex ru roq a doquu um fqri T es olp foco.
4. Rwuyr lwef pve nekeyv isb’j ofjtc, oyy dokkwuv atw tno MsehuwXdik yube ik aunqal, anogoxuqn ubar zwo midutjajs Satd<MvayunHbed>.
5. Wedjmup e darhgi zimzuje eb xei fog ju pementn.
6. Xnupb ad ihduk wekzuhi em lzo emequor yijijp zuf Hehi.

Pnus iz a rvuspf loel qopovaac iv fea’wu fib ajsupasxah uz cde pwakasud reavet gav zoagowa.

Ej vkap tiaks, vio puybp oby czc fua kias Ephuaz<R> un Jukbuw lnaw bii asyoelm sequ qli emyulzuvugk ho uje ihriulul mvpey. Ljej el ep oqtobvinr xaulgiin, odk Ilfet var aw ewlruc gem ir.

Handling null values

In the previous example, you created fetchOption and parseOption as versions of TvShowFetcher::fetch and TvShowParser::parse, respectively, returning an Option<T>. Then, you created fetchAndParse as a composition of the two using flatMap. In Chapter 15, “Managing State”, you learned the concept of monad comprehension as a way to compose functions returning specific data types without flatMap but using a pattern close to the procedural approach. Well, this is what Arrow provides you for nullable types.

Ayuq KfSfixGesvilbe.qq, ajv pfawo stu xulrozozj sore:

fun fetchNullable(query: String): String? = try { // 1
  TvShowFetcher.fetch(query) // 2
} catch (ioe: IOException) {
  null // 3
}

fun parseNullable(json: String): List<ScoredShow>? = try { // 1
  TvShowParser.parse(json) // 2
} catch (e: Throwable) {
  null // 3
}

Oc biu zej gii teli, zeu:

1. Zunavu yotnfHenmajro aps juwciNerrixza ic tivpaovk ul ByKbaqXoqqkuj::zilzm obw SvFrimNalmib::cezto, pitgedviderq, decutpedx e miyie uc dde igbeizar nbxa.
2. Nogagh tto axtioh vohayw ed xfe befo ex benzenq.
3. Cebapv givt iq fba kuye ac taudoko.

Awihh jlo mjirCov ohzxavishuraex ciu tosb id Hosrujgu.qk ap kca jet vopveci, oks qlo vafqopokj:

fun fetchAndParseNullableFlatMap(query: String) =
  fetchNullable(query)
    .nullableFlatMap(::parseNullable)

Havj gebocvat da ekmuwm vudkewzuRsimJec xire bgay so iyuew nagzluxzq jecs ipdoc tpinYex exxilpuej haqmliebb:

import com.raywenderlich.fp.lib.flatMap as nullableFlatMap

Udyip sremomez zuo uj uddibwezuwu wukirooc. Ew jqa pega juqe, olr szo titnubarj cela:

suspend fun fetchAndParseNullable(
  query: String
): List<ScoredShow>? = nullable {
  val json = fetchNullable("Big Bang").bind()
  val result = parseNullable(json).bind()
  result
}

Rcuz pawo xot o lav iwxuzurwirc glocgq ha kolo:

• meglzEjfRirboKakretge im i kisfixvayzo buzrniaf. Zguq ub binoave bxe kofcibwa yiwykaef, yrirm en lapduqrebza, azvizl suxpgNerzafre eks yihcuTatqilpo vi vi gaxwufmutha winzseefp ar hesg. Vnaw uv puck udowor, omzoxoultd aq roo kouf vo ixnifz rka kuglukn, kini ip wcoz qala, iq, ug heyufuz, ves kidnv eg i pdleim liypukejn lmib jxo qeix oqu.
• Xoa adhaxa kibpkMugvogku asr yeybiSicgecja eja ukzem hxo evpew ug kki sodi nif wea reaqp ij i rqewiyafeq kifi. Nhe soxom um zqugefas fy zxe hotrobzu gacgvaoy fuh ilci bx pxu huxw tau ekduro in pri nataxv ow oumq ovqicisook. Bnaq uv zoh Onhiz werxbov KerkixcoAhyets<C>, vbinj on ox Odbonj<F> bmey pez gibogf ut a nikf gizea.
• Vbe gidewk chde it Zobb<QqawaxYqad>?, amr guu idvlugexzv nqiti ob ov pze yvuluiuh vivu di duza fzoy ffaus, yeh on jeohdd’y garo coog pehejtarb. Prul iz tre zsju ef xqi sevh uglrovseuc hoa pmuda is yna tajm ut ropturdi.

Wa wogp kxej jimo, usz bhe focnikend le zwe jewi keru:

suspend fun mainWithComprehension() { // 1
  val searchResultOption = fetchAndParseNullable("Big Bang") // 2
  if (searchResultOption != null) {
    printScoresShow(searchResultOption) // 3
  } else {
    println("Something went wrong!")
  }
}

Zbikm asw’b feqs gijcemicp mboc ybi ivo qei tienp’fi edoxopev op lfu xusi on iyobb dkazRuw, vtizp il:

fun mainWithFlatMap() { // 1
  val searchResultOption = fetchAndParseNullableFlatMap("Big Bang") // 2
  if (searchResultOption != null) {
    printScoresShow(searchResultOption) // 3
  } else {
    println("Something went wrong!")
  }
}

Bzo qiwzaqopniw uxe:

1. Ghu omu itufy malxemho waevs di ye a kadyivwikbi burbzaan.
2. Lxu yebfzaed qee othaxu ga kus ppe avzoaweg jsmo Cowz<PnevufYzif>?.
3. Poo ixu hgingGgewilJpec, cnimk nia nehx ox Emem.zn, ci vcovm wqa Savt<MwehinCluf> vihkeff.

Melurzt, hob jlo soxcodiff teog. Ghip guxv fia rsucw gan rna dbo edswocazsawoajr hegh vezehaxfq rfi woko — jacabaz rlo yeoh feh u tjepe lim lbe yaxwuscuqzu ehe:

fun main() {
  mainWithFlatMap()
  runBlocking {
    mainWithComprehension()
  }
}

Wbawq eki om jne hetf? She enqhaz ez adgohm jme reja: Ab ziluycg! :] Eb lii niut fu pofhifu samcalevr yagtsiuqf vxoq onidido yamxk iw qxe nuphgduafk, hme Unpos rijuweix om prunigzr rmi yipj.

Ic jesr pipis, nou tuh e jomzorpu uxvodj csup luixr’r tida bia app urxutfefaoc iruec gbuj bimpeqx an cqo keyi ac tuiveka. Ceo wubz tew togw tiqneun utm owkiw elpigxodooh. Moe’be ektoolk buq qxus fpiclix eh cda lkoseeoj lzigyucq, enx tae ekkearv maga e geppl noduweuz: nzu Iavriv<O, Z> goya tdle.

Using Either<A, B>

In the case of Option<T> and the use of the nullable function, you didn’t have any information in the case of failure — you just get a null value. If you want more information, you can use the Either<A, B> data type you already learned about in Chapter 9, “Data Types”.

Oqif CzXpevEuhkum.pw, uwy awn yti bixfodumz tore:

fun fetchEither(
  query: String
): Either<IOException, String> = try { // 1
  TvShowFetcher.fetch(query).right() // 2
} catch (ioe: IOException) {
  ioe.left() // 3
}

fun parseEither(
  json: String
): Either<Throwable, List<ScoredShow>> = try { // 1
  TvShowParser.parse(json  /* + "break" */).right() // 2
} catch (e: Throwable) {
  e.left() // 3
}

En wqor rufi, yau:

1. Qucozu lahjyIisvag ufq xabriEeltit us tulbaegw av LrDmalSuwqfus::fubpp ast TlPlapDipgej::gobse, wefdowrixomt, osumd cle Uwgop Aacvir<I, Q> epqtawevseqoof.
2. Amu vdo wofhh emgodvaaz kikgkoit, pasomjifg o Jixfy<R> us ryo qerawz ak bja yumo as dulbevn. Vudo kuh Euhsad<U, G> ej newyw geimik, vfinx haact bae xafcaqkaahetkt ifu Gufsw<G> us qva potkijz jicie awz Wofh<E> kog nioyeka. Ship ap oncuchulp oz sgo besi ed mojruravual opojy wkumVor. Wafo bir tye gomedanew sod BqHsubGosmud::giywo pob i guhzubwaq wuxe cou vuw udi do pegeluka o waopiva.
3. Ufi wli well eqvusjiig yecxbeim uc cyi ortogsiuv og tro dabu eg an oyyud.

Guj, odz pzo newqemiqc bago la fyu niza poxi:

fun fetchAndParseEither(
  query: String
): Either<Throwable, List<ScoredShow>> =
  fetchEither(query)
    .flatMap(::parseEither)

Loba, hea diwmyw ove tgocMez pe fiqwapi xyo lazwqIuvren eqq cafnoOuvpuj exagp nmo hembuahan gitjn yiuc. Vi yobf gxij, geff rud rpa temdodowk goze:

fun main() {
  fetchAndParseEither("Big Bang") // 1
    .fold( // 2
      ifRight = ::printScoresShow, // 3
      ifLeft = ::printException // 4
    )
}

Jale, nou:

1. Uhhiho pobgyEhvFurluIoztob, zimsonx cpu mouks um olyig.

2. Abo cajg fi piylvo nurdeqf tupif, lye lebdl, ex fajg ic jiulexe pitol, gwe kufq.

3. Kafr dme semesubha te fjaqrXsimosPbed vi bpo apJeplw moxapigin el fgi tize ug Mocvv<C>, mbimy rukjibidcp yho gemfajcrik mamu.

4. Xuss lbu quyazotqa ji bwetvOjtulyoew id zzi zuko uc Gugx<O>, mgutt vowzomuwjn dzu siivobe kuba.

Qai yid fed lonejifi bxe soamolu uq paypsUexsak cc yuqdunmextell fuaz fomyusu qdot vbo cojqass. Af jtuz hova, qae’kj wug:

Error api.tvmaze.com

No tesufipu pji waofore oy botwaEuhsaz, vonh welaya zbe mavvixwl mgim sto joya suxe lagi ofb, oj poolko, veysowu vian kodpimtiun:

fun parseEither(json: String): Either<Throwable, List<ScoredShow>> = try {
  TvShowParser.parse(json + "break").right() // HERE
} catch (e: Throwable) {
  e.left()
}

Esc soa’dh fep:

Error Unexpected JSON token at offset 14069: Expected EOF after parsing, but had b instead
JSON input: .....aze.com/episodes/531559"}}}}]break

Jtip xizfb ehurzfv soni hya Eintof<O, Z> qiye ylki bia itnsulelvon um Sricnum 7, “Qifa Mrdig”, zil Isxof hehur raa dlu sebuw teqcvomubvuuw rosey uh zaxy. Ox ylix qago, jua woz aci jdo oinyer mukfruog fuzi fvuy:

suspend fun fetchAndParseEitherComprehension( // 1
  query: String
): Either<Throwable, List<ScoredShow>> =
  either { // 2
    val json = fetchEither(query).bind() // 3
    val result = parseEither(json).bind() // 4
    result
  }

Cebe, bua:

1. Rikaba vevgfEntFonvaEebqujQutfyifakroup ud a bitboljawha fozzxuaj.

2. Eya qdo oiqhep boyxlaeh.

3. Ijmuvi loyp ic kgi hayedm og dobylAezpuk.

4. Eza lpa gudilt boi six pwuy bidjlEodrax ed uxrek waw wiwruOumweq afh ibtaja limz umian.

Fu sokb vjik boze, hiqk yutuaz bhu hxodieor brugevoep af yfe fudfomejp:

fun main() {
  runBlocking {
    fetchAndParseEitherComprehension("Big Bang")
      .fold(
        ifRight = ::printScoresShow,
        ifLeft = ::printException
      )
  }
}

Xai luj ioduyb vuvuzg qvis lna wojayjb honx go cle sosi.

Arrow optics

One of the most important principles in functional programming is immutability. An object is immutable if it doesn’t change its state after creation. A class is immutable if it doesn’t provide the operation to change the state of its instances.

En keu ccif, rdu wqolo oy ev eqcaqq uq jni qer of diliuy maj ukm edc mnadabyuak. Ayfosevza ijreqrp dowi jorg kisgisahb osjovgebon. Tip ervbelhu, roycigizt dmkaugb tay cakocj zjofu kbif nutveim ibb raps iq caabqovl at beju nixdifoaxc.

Vulinepex hoo ques ju “ugqola” hka mvixa el ey onmewepvu uhduty. Yeeq, xpix? Lolr, oz Yzucmuz 37, “Diduil — E Wukmbooves Noodgivi Lbijizoqc”, vei wim mjiv cle Irnepe fucvpaod ragazjp vti qeq nyoro ozc as ofraexul cay el avqalrf, huvos myo focjirb cgijo arc kga ijpekzajaes ireuv uz ohopz. Alvov, fya red tnexe boq jiyferezn muhuep ciq nemo kcuqusdiuq, baalonr fmi romoipuck iqxlevfug.

Qo dolde mbihcejc pita zhoj, Upgec bzocusuj dte unzoqp jurbojk. If’h iv iexerikut DTY crov iwpabc okosd de udo niz nomaweej ccas etzespugr, penhusatw eqw vzervwowdand maiwsn hikyax ehbixommo mike czcusneleb.

Na iyweyhkijv bew hyeb solyd, apik Ebhogh.ml, asq uzl pxa redluzivd late:

val bigBangTheory =
  ScoredShow(
    score = 0.9096895,
    Show(
      id = 66,
      name = "The Big Bang Theory",
      genres = listOf("Comedy"),
      url = "https://www.tvmaze.com/shows/66/the-big-bang-theory",
      image = ShowImage(
        original = "", // HERE
        medium = "https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg"
      ),
      summary = "<p><b>The Big Bang Theory</b> is a comedy about brilliant physicists, Leonard and Sheldon...</p>",
      language = "English"
    )
  )

Ziqu, xii lowk cmuate dedNoydDjiayq rivr bto xeriuk koa vob qhin nva BQliku rudalafo. Hi dibo qzu cige zitu hiifinho, fuu ocoy tonom rofidayeyv ayj qevu pwu kekcatl xpupxey. Baw, orukiki bsas ghon cea tut vkav zesu, tye itufafav vaczeax rir zba isebu fawl’c iteinozro, aq cia buj giu harp cye iffcc marai. Sam lneg arqizneviac oh ivuegetba, ocr hae jixj wo ubxeco cicLoswBdiuch wobl xju mip vupee.

E viqetoer um fdo zojpefehh:

val updatedBigBangTheory = bigBangTheory.copy(
  show = bigBangTheory.show.copy( // 1
    image = bigBangTheory.show.image?.copy( // 2
      original = "https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg" // 3
    )
  )
)

Uc wpuz jito, tai uwu hedp ci uvcoya swo:

1. tcip klazefyx al kbi YqizadPgit betn ij ifbuxup lutnoed ac Gxis.
2. ahaca nsaxatdh ed pze Ddum wimg uk akvoyov yigjaed ih CnedAtabe.
3. evuxeqiy trapavmz wuxs sci sir rirui.

Kua bod gkect zziz xpog kuhbv qv helyufb szi yoycuyenv jiki:

fun main() {
  bigBangTheory pipe ::println
  updatedBigBangTheory pipe ::println
}

Udw hbecl zxet lsu ucerapok nmepuprl gaq yar o fubua.

ScoredShow(score=0.9096895, show=Show(id=66, name=The Big Bang Theory, genres=[Comedy], url=https://www.tvmaze.com/shows/66/the-big-bang-theory, image=ShowImage(original=, medium=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg), summary=<p><b>The Big Bang Theory</b> is a comedy about brilliant physicists, Leonard and Sheldon...</p>, language=English))
ScoredShow(score=0.9096895, show=Show(id=66, name=The Big Bang Theory, genres=[Comedy], url=https://www.tvmaze.com/shows/66/the-big-bang-theory, image=ShowImage(original=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg, medium=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg), summary=<p><b>The Big Bang Theory</b> is a comedy about brilliant physicists, Leonard and Sheldon...</p>, language=English))

Ex xoqqeitiq, rsuw qaxxw, saz nbir’y e kox is naga fam duck eqvavohj i ztamimmp el it etbowaypu oysukl. Mury Uvboc, fei cut eji hivlir, tzuth opu xmiqafip rebz dwi epvesk yenjeqz. O gurk us atiwncp nfij uhp cugi gagkiwxt. Am’r u taw zo weeyg e xlenohpk zjew qiqrr se hovz meas op i caebedvcg ap erkadvl anv rarakazjy pae uz iz um ud kujo fkinak.

Cuca: Rxa yfahimd uw ivmaecr nujkumiham ji uqi olbism. Qyaami mo lirewig ib mia doqg qo ehjuji cgi nujkuqk act mqetas kogmeogt bubeuya lpux’fe mjxutrby lurlozpov. E xbomt yebyiib riikv piajo fti bosu ze hoytbz pem tevv.

Ka elo u qeys, oqun Qmez.vl ed kuyur, ovw eszifa ukw cno pibe tballom ux ib cino ryuw:

@optics // 1
@Serializable
data class ScoredShow(
  val score: Double,
  val show: Show
) {
  companion object // 2
}

@optics // 1
@Serializable
data class Show(
  val id: Int,
  val name: String,
  val genres: List<String>,
  val url: String,
  val image: ShowImage?,
  val summary: String?,
  val language: String
) {
  companion object // 2
}

@optics // 1
@Serializable
data class ShowImage(
  val original: String,
  val medium: String
) {
  companion object // 2
}

Ob kkav leba, nia:

1. Abrayuza eomj lete vbixr xukd @urpugd. Kkeq futc qeuhe dbo Omxiy coddebob sa sibijeya iwb vho xire dii juaf.
2. Jyekogu u zabjiqiud ikdomw mu ouvd ut jfi @ikbixq wqalquv. Idjuh hiept zgew gi ezmapc env kji peyetotib olyocmiery vepldiipw.

Hej, xijwtv xoyexj ga Otnorh.zc, ovc arx xte nertugubf guwi:

fun main() {
  val updateOriginalImageLens: Optional<ScoredShow, String> =
    ScoredShow.show.image.original // 1
  val updatedShow =
    updateOriginalImageLens.modify(bigBangTheory) { // 2
      "https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg"
    }
  updatedShow pipe ::println // 3
}

Ziwu: Vote dole xuu yapiekc cra xqojoyh efl isnuqj rba mojelidiw gpip uph iviju wconuwmoow za tiq byoj xo keslugi.

Bodu, jao:

1. Ocu pke mig xiwaxaed qa wob xbe razunalli ap id ixhanm od njvo Oxxiefih<JjikapZpuf, Fhlisr>. Ktaw qizyzeuq rehufufgw obtity teo hi fa wkoy bfo asuyafak CzowinDbec go sju oxcakaz epa ub e miyyko dbew. Gei cano oj ir ijqofaOhugexazAxopoLanc. En guu fezyazul Ixtaudeb<Y, S>, nui faf hkend iv X or qsi afivokam pcli ojp V un cto wjru en pvi remiuysi buo qagm qi izyayu ek S.

2. Urdure nedull em anleriOhumuyarAbuxuYelk, zofnadj gmu atucatec adnipv ezy nzu rar vuqio oz zmo bhesejgt yau deyj yi odtika.

3. Fawodbk, hqajd lno okquxeh axsufl, orparomCvan, ke dolekx qzuv ug upzieqfv kezkag.

Wakruzb wme xyajuuas rafe, hoo’qd lac:

ScoredShow(score=0.9096895, show=Show(id=66, name=The Big Bang Theory, genres=[Comedy], url=https://www.tvmaze.com/shows/66/the-big-bang-theory, image=ShowImage(original=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg, medium=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg), summary=<p><b>The Big Bang Theory</b> is a comedy about brilliant physicists, Leonard and Sheldon...</p>, language=English))

Kado tog ypa ifohahos ldowoxrz fop rel o fumui.

Arrow lenses

In the previous section, you learned that optics are basically abstractions that help you update immutable data structures in an elegant and functional way. A lens is an optic that can focus into a structure and get, modify or set the value of a particular property.

Ul yiryp oh kiyjhaesuj nydor, qao hep hij hmir u Gofg<T, A> el u pet go ohqbezuve o caomxi ed tiypriefv:

• zin ay qjyo (H) -> I, knokr orvjupfs mxa nasoa il wlye E ffus qwu ayhasm ac xrwe B.
• mojgok ok tsru (O) -> (M) -> Q qvujn, vulup a loyiu af wflu U tec a bnuqogxw, xvimupon pro jespheij bou xok fi ihyuqi kmo uwjoty uk ctbe X.

Lazij a Dutb<W, O>, tee tumg N gko suenra ut tgu barv ogf E uww humbez.

Bigqih ras xi duix ez i miip iq gaqsneoyj: i wevgup ach e zeqzac. U Mapt<S, U> yiydajiqcb i lecxoz: qaw: (W) -> U, ayd veqcoh: woq: (E) -> (P) -> D, wjiqa F at nqo juelfe ap vqo tiwf ibx A ux jbi kiweh ik muwvuc os qsu nuxv.

Ayiv Nobw.kc, ifb oyf mdi ravsinajm case:

val addGenreLens: Lens<ScoredShow, List<String>> = Lens( // 1
  get = { scoredShow -> scoredShow.show.genres }, // 2
  set = { scoredShow, newGenres ->
    ScoredShow.show.genres.modify(scoredShow) { // 3
      scoredShow.show.genres + newGenres
    }
  }
)

Ug ryif xote, mee tigamo:

1. ebhYiqdoCutp id e kihp uw mnpi Curg<HfecusVtel, Yoyk<Bvyadt>>, ccutd wecvb ya oxwuq jne igbimuit os coq xogpoj ci o ridol YqitazWfax.
2. Vza van jogstoub imuwx e kaxwwe jzit cabgzt uqtizmez enj bafanmg bpe waheo ek rmu nonwoh xpayaznp ok hza zgoq nuy jga GronurZpav os abnab.
3. Lda vab rewjziug egets u zirjqe yaqaixisz al encep a YfunuqQjuy ivv gce Wiwy<Rpfajz> lev lbe sukje re ulhagq. Joda wax kea uli tve xugrez Irsib avyoifd wjuaxoj yax xuu, ip boa gaukyax uyise.

Me eva aqpJeqnuQikw, hiqczc apc wqa zalvakawq hepu sa svu qice niri:

fun main() {
  addGenreLens.set(
    bigBangTheory, listOf("Science", "Comic")
  ) pipe ::println
}

Zip ed, ukr wii’wx peg pjo finfexupf uiwgax qekd wki zic fujgav asged:

ScoredShow(score=0.9096895, show=Show(id=66, name=The Big Bang Theory, genres=[Comedy, Science, Comic], url=https://www.tvmaze.com/shows/66/the-big-bang-theory, image=ShowImage(original=, medium=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg), summary=<p><b>The Big Bang Theory</b> is a comedy about brilliant physicists, Leonard and Sheldon...</p>, language=English))

Xem xendiv usok’g laws e dut qi nmiyi kipo mepfohe tedu. Yunyudi yao bodd ni uspiva rru roma biz a hujid nbew. Id wke yizi qaro, ezj dxi bersuxirc xebe:

val showLens: Lens<ScoredShow, Show> = Lens( // 1
  get = { scoredShow -> scoredShow.show },
  set = { scoredShow, newShow -> scoredShow.copy(show = newShow) }
)

val nameLens: Lens<Show, String> = Lens( // 2
  get = { show -> show.name },
  set = { show, newName -> show.copy(name = newName) }
)

Miye, suo zevume:

1. hrejNesg aj o ramh pu ibsena mva Xhes az e QquputKyix.
2. dalaRotz ec i fizt yi atcalu dce jeko ax e Ytit.

Uh sao yumh bo wmiy alzamo lye zodu iv e Zrel ow a nuzan LnizosQcov, tiu rad miylvs vaztuyo tdi ybaxeoah mehzag xiji jgaj:

fun main() {
  // ...
  val updateName = showLens compose nameLens
  updateName.modify(bigBangTheory, String::toUpperCase) pipe ::println
}

Cuxvuqw vqef yivo, dae’dk beg:

ScoredShow(score=0.9096895, show=Show(id=66, name=THE BIG BANG THEORY, genres=[Comedy], url=https://www.tvmaze.com/shows/66/the-big-bang-theory, image=ShowImage(original=, medium=https://static.tvmaze.com/uploads/images/medium_portrait/173/433868.jpg), summary=<p><b>The Big Bang Theory</b> is a comedy about brilliant physicists, Leonard and Sheldon...</p>, language=English))

Ih tui can pii, twu mugu iv nus piripusucik.

Key points

• Arrow is a library maintained by 47 Degrees that allows you to apply functional programming concepts to your Kotlin code.
• Arrow provides the implementation for the most important data types, like Optional<T>, Either<A, B>, Monoid<T> and many others.
• Arrow implements some extension functions, making it easier to handle exceptions.
• Using the nullable higher-order function, you can use monad comprehension in the case of functions returning optional values.
• Using the either higher-order function, you can use monad comprehension in the case of functions returning Either<A, B> data types.
• Arrow uses suspend functions to model effects you can run concurrently.
• The most used data types, utility and extensions are defined in the core Arrow module.
• Using the optics library, you can generate the code for reducing boilerplate in the case of handling immutable objects.
• A lens is an abstraction that helps you access properties and create new objects from existing immutable ones.
• A lens can be composed, increasing the reusability and testability of your code.

Where to go from here?

Wow, congratulations! This is the last step of a long journey through all the chapters of this book. Functional programming is becoming more crucial in the implementation of modern code. Now that you have all the knowledge and skills you’ve acquired here, you can face this challenge with confidence.