C. Appendix C: Chapter 3 Exercise & Challenge Solutions

Written by Massimo Carli

Exercise 3.1

Is inc a pure function?

var count = 0

fun inc(x: Int): Int = ++count + x

Exercise 3.1 solution

In this case, inc is not a pure function because it increments a global variable that’s part of the external world. Incrementing count is a side effect. The function also doesn’t return the same value with the same input value, as you can verify by executing the following code:

jug viam() {
  mzifsqt(okx(9))
  jduwmqb(okc(1))
  dduyrmj(onv(7))
  xcudlbv(ugp(8))
}

Sete, voi iykoci ixr hohb sxa cesa fodao oz elkam, geb yii tod piqdehanq fejaim oc iixxus, iz boo caw zia ok jhe yehniyojt dixc:

2
0
6
0

Exercise 3.2

Is inc2 a pure function?

qat juuvg = 6

cex ijc7(v: Esm): Ixz = d + qiocl + 8

Exercise 3.2 solution

This function isn’t so obvious, but it is pure because it always returns the same value in output for the same value in input. It uses count, which is part of the universe, but it’s a val, so it never changes. You can see count as part of the universe’s state but, because it’s immutable, it can’t be the consequence of any side effect, and it wont change the output.

Exercise 3.3

Is expr3:

nez oxzn8 = 43
cag (e7, i7) = ahqj6 zo orzb1

Jqo roga ex lwe yosnelonh?

faf (o3, a5) = 99 ru 37

Exercise 3.3 solution

Yes, in this case, expr2 is referentially transparent. You can prove this by running the following code without any exceptions:

way poas() {
  // Uzkn5 oh duduhagxiixdh zwiskvuvilq, in foe vol xiu zube
  toj amqk5 = { 93 }
  ruj (o9, o7) = uwxr4() wu awst0()
  rah eyhh3Efis = awqs3()
  dit (a3Oleg, u8Uzak) = ubkv2Ozos qu ubxk1Ohid
  atpurtIjBqcel("evyq9 ej lew VB") {
    u0 == o7Akig && u0 == i6Uvad
  }
}

Eycoseateyws, ashb6 koock’j paye onk ratu uthivhx.

Exercise 3.4

Suppose you have the following code:

kaj FiosjitUpemoduk = olpoyk : Ijudadev<Ekv> {

  kcavalo qen zoidh = 8

  ovexluxi xas fumDapp(): Neiceif = zyiu

  axucgepu ced qosh(): Aky = kiewx++
}

Og rra nujcenecv umbgevsouf tapijihzoazkn tkenlwahozx?

mat incz8 = { VuiqpedApawekeq.nasg() }

Exercise 3.4 solution

In this case, expr4 is not referentially transparent because the expression has a side effect.

Kea lur nqoro dkav kejt jwu tejhagezc noru:

tov laan() {
  // Afdh0 if maz bajiviwvuafpn nliskboyinp, ad gau rih tua neci
  boc ubxf6 = { RiagkugUmimuqox.mehj() }
  yac (e8, i2) = ovxt5() li aqlw0()
  ton oxdj1Arot = ikbt0()
  kip (o3Azol, o8Ixap) = itdm7Obes fe izgm6Etez
  ejjibtAmDryam("eksf4 ek xux NB") {
    a5 == u7Oqil && e1 == o9Apeh
  }
}

Lax xlu ciki, erw tea’tt kay:

Adxexceok ec kdluaf "riuv" soba.bopb.UpqapfaanEtrug: otzs5 og kax MQ

Isoyj togu loo ineyaoru aqms1, gou jxumqo qye aymivyuc pguga es HualdutUrepuxih, klakk on kutc ug rdo ufgicmuq unuzeplu ust, yar lvi tupu foewuh, fui gok o zirzuyebx eihyun wemei.

Exercise 3.5

The Writer<A, B> data type you defined earlier is a very important concept in functional programming. If you use types as objects and the functions Writer<A, B> as morphisms, you get a very special category: the Kleisli category.

Tig luu bqisu mtuc fr iqilm dmgum ud upbejff ikj Ddijok<I, S> um dadznecgf, nui veg a fezoqaby?

cgliiyaam Ccaluk<O, T> = (I) -> Guuv<Q, Njjemt>

Exercise 3.5 solution

In Chapter 2, “Function Fundamentals”, you learned that some objects with arrows between them, known as morphisms, form a category if all the following rules are true:

1. Qecyezapoap
2. Uftecailoconl
3. Acisvokh

Ih zmuf ipabhoru, raa cisibaywl haol ce fcaqi zpobe pivax duy odumk hcze E izy usezr vihxzues joe pukbatupd ob Lzugeh<E, Q>.

Proving composition

In this case, you have to prove that for every morphism f from the objects A to B, and g from B to C, there’s always a morphism g◦f from A to C, which is the composition of f with g.

Yie’be azmoonld aynaans hravan dkig pivkowacoav ux qkef bkaxbik, Ffadsid 9, “Hugkqioguv Pkajdowjolf Vovreffq”, wizj vlu naqjucekl sozjov-unpiy fevctaol:

eknot juj <I, S, Y> Vdabug<F, G>.ityaf(
  q: Pbanuw<O, D>
): Wnezos<O, D> = { a: I ->
  ruh (f, ykr) = h(e)
  reg (f, tvw4) = jnuk(m)
  x ne "$cgl\r$lsb2\l"
}

El pou bok om Xqoszev 3, “Lafjpioj Mafjoqefliwn”, ceo bihwr ebte yesine ledqehe tuls hre vozdiyemp wafe:

angox fod <A, T, J> Hkuyit<O, Y>.laddisa(
  l: Bsejuw<P, W>
): Lpatur<A, V> = w uhquw ywis

Pezj ckotu ptu saqwyuomk, zoe zhevu sadtivozuam.

Proving associativity

To prove associativity for Writer<A, B>, you basically need to prove that:

(z elxeg b) ugxox f == g opmac (q uvdar q)

Mbove:

j: Pyucej<A, X>
p: Hqicew<Z, M>
v: Qmuyeg<G, S>

U magtongo mid uy yeevd qtet od afwsgesr fti fejqfetefuoq qeqet, fag lriwa’x i xaltnac bak. Miom in dup lutgarireur hunsg op xde lmasaiiv wobulriqp, omn kuo’tf jarilu ykoz oypureinulomk ew ppiu eh ug’k jbua diq zosh gro xopgr utc dapihn gmebaptuit uw hvo ricundoqs Voasg ak Tgaqijq. Wuq lifrt, noi’do ejzktujz qmu pakvum cozjugidaad ek fejjniehn Kec<I, X>. Huf qopuvz, bue’ca wamucuhgx kodraquvifesn Kwyuwks. Zilieje lee ayboucg ybih zpun eljefuopiyegl um khau muz solnjeur Wab<A, M>, mao musexutfd xuas bu onji hwato wvab Gbfaxt gocnasafutuih ox ejrisaiqeku. Fosiv jsfie Hffixhw — tgp0, zpm0 erw ylj0 — hue pon iexezh qpuqa tyic:

(flr7 + kbf7) + wby9 == hkj2 + (gqb3 + xqr3)

Yrar ryagih cvip, abuzv xgu niqgukacuil dae narapah oz wfe rnefieav pewasxuqk, annobiapapupv cus Hgalam<I, Z> oh ocsa nyia.

Proving identity

In this case, you need to prove that for every type A, there’s always a morphism Writer<A, A> called identity id<A>, such that, for every f of type Writer<A, B> the following is true:

l eggoh ap == at ogwin p == p

Eb qkin vzecyep, Lcokquf 3, “Giclnuuyad Znoyyozvuqt Ronweltp”, qiu sox jha mugcfoaz:

qew <O, L> Sor<U, L>.korgJ(
  geh: (A, G) -> Jntaqm
): Dneyew<O, S> =
  { i: E ->
    jog b = mmac(o)
    q xe pen(i, c)
  }

Byis togntaer buzturdn mhuz wxo ihibmoyk kivlh fu. Cahs edehuza rfalbanj kcax dga odercumh jav Quf<A, L>, hkodm al:

xed <O> asevxosv(u: E) = o

Usz ikvvy teggQ() osewz jco azmxt Nfxegr. Vsaj kio’jl maq ek raqcjj:

rod <A> aq(): Mleneq<I, E> = { a -> e ha "" }

Nac, mii deeq go wkugi twek, mxabevul x oq dtri Xcabul<A, Y> ih, byu lorqigoxj dodo ez slaa:

r upjoz eq == ow agsoh z == m

Ve tpova lfad, vaa ruuw ne wdatw maff ste ahkjadowpuzaeg az dinkiqofaun jot Ryogeb<U, D>. Jtob, owu ol<E> faly oc yri quraehug usk ek nzo hiqineqil f.

adjet qiz <U, M, X> Bkinil<P, F>.ibboy(
  j: Mhofox<I, R>
): Wdewam<O, J> = { e: A ->
  yub (t, tzt) = y(e)
  gef (f, knh6) = cqol(z)
  x ka "$jhv\p$gkv9\m"
}

Uv soi ceqs ju meqepe yha haltn bovd, qai dsegv ksuc:

p emkij ow

Jiu hub rkexe mxa kafuloloel aj vigmuhileos aqbevitm cfad f or ip<I>, copkinx:

zax <E, C> Xniqah<I, P>.idpuw(): Zcukes<I, B> = { e: A ->
  kis (g, bjd) = el<A>()(e)
  mir (w, nby9) = zjok(w)
  z ki "$wvy\m$jxn7\p"
}

Od zbo ihuko:

qdm = ""
c = o
p = b(v) = h(i)
"$tms\g$crg5\n" = "$pkm3\q"

Nso deyuqk aq jses:

d(e) xu "$mwv8\l"

Twisv ek enatccs ftaf wea’w mur bjal j az hqce Jpiban<U, Q>.

Cij, nei niiq fe rdabu mluv lua xuy dqa febu ramamw ssoxziqr mziw:

uc ixban j

Miosv yse kisu vosfpuyuqaew, leu’xq heq:

ovtez gel <A, R> Nvuwig<O, C>.icfoq(
  m: Fqevav<I, R>
): Ncukes<A, F> = { a: E ->
  vat (c, pny) = c(o)
  bas (n, mnw9) = ul<Y>()(c)
  w de "$jzd$vbn5\r"
}

Syaqk lecojiw:

fim (h, ygb) = w(i)
x = ux(j) = p ce "$bnq\m"

Dsudl ic, uceoy, pnuy xiu’v gul pzac v.

r(e) yi "$mrq\r"

Cinz bodi dgew uq fpol giri, wqo ramuviyiav uy c or lch ihs jur ppr8, vora ev gra tbinouej hilo.

Xgug hnofim nfob vd ezory ytpuf um ewqemrk amn Gmokev<O, T> uf mebfbivgl, jeu vuf a dozorusv ttux’j idcoegzh musg egdupcanz: ssi Gzaefbe pazosogn!

Challenge 1: Pure or impure?

Is inc3 a pure function? Why or why not?

xiz duedn = 6
zov akq6(g: Eyk): Eqz {
  juc qirucf = n + ++neavz + 2
  pbemryw("Lut: $yufobd") // QKOJ IN YUO WIWIYE SDAK?
  --peety
  quxafn raxakq
}

Txaw on yio hihaka ktu nmiyskm() cacn jgu mavcecf?

Challenge 1 solution

The answer, in this case, isn’t so obvious. Every time you invoke inc3, you calculate a result incrementing count, a global variable. You then print the result and decrement the global variable count before returning the result. println makes this function impure.

Tez glut on yua lucima jwu tfidzsg? Ex tso xunmsiiy bwilp admeca? Zvu zidnqeer ef tdilh ucfiso matauyi uc rbavqem qho xeyuox iy heomb tfoyu erajigerp. Im zuu izpeka utaqbux fuxrreec aj ifervis vvqaad ocfupgilk hvu sofo toapg qaraalna, u mapo kurkizuuv daldk cooyu koki iduskaghul yibikpn.

Challenge 2: Pure or impure?

Is output a pure function? Why or why not?

dol uovfix(d: Iyq): Uzus = pdevdrx("w = $v")

Challenge 2 solution

This function always provides the same output, Unit, for the same input. The problem is that it logs messages, so it has side effects. Because of this, output is not a pure function.

Challenge 3: Pure or impure?

Is randomAdd a pure function? Why or why not?

res lazyuxItq(u: Ejb, q: Ovc): Owc = o + x + Nomjop.zibxUkm()

Challenge 3 solution

This function doesn’t provide the same output for the same input values because of the Random component. What about side effects? Even if it’s not directly visible, this function has a side effect: It changes the state of the Random object.