Luku 6.4: Lisää kokoelmia, lisää ohjelmia

Tästä sivusta:

Pääkysymyksiä: Olisiko lisää käteviä kokoelmametodeita? Miten yhdistelen kokoelmien metodeita?

Mitä käsitellään? Lisää kokoelmien metodeita ja uusia käyttötapauksia edellisen luvun esittelemille. Luvun lopussa puhutaan paikallisista funktioista sekä sulkeumista.

Mitä tehdään? Enimmäkseen ohjelmoidaan.

Suuntaa antava työläysarvio:? Kolme, neljä tuntia.

Pistearvo: A95 + B30 + C30.

Oheisprojektit: Election, FlappyBug, HigherOrder.

Tulosarvon tuottaminen kokoelman sisällön perusteella

foldLeft-metodi

Luvun 6.1 päättäneessä turnElementsIntoResult-tehtävässä työstimme ajatusta siitä, että kokoelman perusteella voidaan muodostaa yksi tulos (esim. kokoelman alkioiden summa tai tulo) soveltamalla alkioihin tiettyä funktiota toistuvasti. Tarkemmin sanoen: sovelletaan tiettyä kaksiparametrista funktiota (esim. yhteenlaskua) ensin johonkin alkuarvoon ja kokoelman ensimmäiseen alkioon, sitten näin saatuun välitulokseen ja kokoelman toiseen alkioon, jne.

Tällainen hyvinkin yleiskäyttöinen metodi on määritelty myös Scala-kokoelmille. Sen nimi on foldLeft. Seuraava käsky on eräs tapa laskea kokoelman sisältämien lukujen summa:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.foldLeft(0)( (sumSoFar, next) => sumSoFar + next )res0: Int = 4

foldLeft-metodilla on kaksi parametriluetteloa (kuten tabulate-metodilla; luku 6.1). Ensimmäiseen kirjoitetaan alkuarvo, joka on samalla lopputulos siinä tapauksessa, ettei kokoelmassa olisi alkioita lainkaan, ja...

... toisessa on funktio, jolla yhdistetään välitulos ja seuraava alkio. Ensimmäisessä esimerkissä kyseessä on yksinkertainen summafunktio.

Tässä luvusta 6.1 toisintona (päivitetyllä termistöllä) graafinen esitys, joka kuvaa foldLeft-metodin toiminnan:

Summaavan foldLeft-kutsun voi kirjoittaa yksinkertaisemminkin. Alla on myös esimerkki alkioiden tulon laskemisesta:

luvut.foldLeft(0)( _ + _ )res1: Int = 4
luvut.foldLeft(1)( _ * _ )res2: Int = -20000

Ja tässä parametrifunktio summaa ensimmäiseen parametriinsa (välitulokseen) toisen parametrin (seuraavan alkion) toisen potenssin. Lopputuloksena saadaan alkioiden neliöiden summa:

luvut.foldLeft(0)( (sum, next) => sum + next * next )res3: Int = 566

Sivumaininta: helpompi tapa laskea summa tai tulo

Koska tässä luvussa on puhe korkeamman asteen funktioista laatimisesta, niin edellä "unohdettiin" eräs seikka.

Kokoelman alkioiden summan laskeminen on kovin yleinen toimenpide, ja Scala API tarjoaa valmiin metodin. Saat alkioiden summan kutsumalla kokoelmaolion sum-metodia: luvut.sum. Tämän metodin toimiminen edellyttää, että alkiot ovat sopivan tyyppisiä (lukuja). Vastaavasti product-metodilla voi laskea alkioiden tulon.

Kaikkiin ongelmiin ei kuitenkaan ole yhtä helppoa valmista ratkaisua tarjolla kuin yhteen- ja kertolaskuun. Kuten jo näit, foldLeft-metodilla voi paitsi laskea summan myös muodostaa muunlaisia tuloksia alkioiden perusteella.

Lisää fold-esimerkkejä: alkioiden tutkiminen

Yllä tulos oli aina samaa tyyppiä kuin kokoelman alkiotkin (tässä Int). Tämä ei ole välttämätöntä. Voidaan esimerkiksi muodostaa lukujen perusteella Boolean-tyyppinen tulos.

Seuraavat foldLeft-kutsut etsivät kokoelmasta tietynlaisia lukuja yllä käsitellyn exists-metodin tapaan.

Tämä käsky vastaa käskyä luvut.exists( _ < 0 ):

luvut.foldLeft(false)( (foundYet, next) => foundYet || next < 0 )res4: Boolean: true

Alkuarvona on false. Tämä on se tulos, joka saataisiin, jos vektorissa ei olisi alkioita lainkaan. (Tällöinhän ei ole myöskään negatiivista alkiota.)

Ensimmäinen parametrifunktion parametreista on siis tässä Boolean-tyyppinen. Tämä välitulos kertoo, onko negatiivista lukua jo löydetty.

Funktio palauttaa true, jos ja vain jos negatiivinen luku oli löydetty jo aiemmin tai nyt tarkasteltava luku on negatiivinen.

Tässä lyhyempi versio edellisestä sekä esimerkki, jossa saadaan false-tulos:

luvut.foldLeft(false)( _ || _ < 0 )res5: Boolean = true
luvut.foldLeft(false)( _ || _ < -100 )res6: Boolean = false

Lisää fold-esimerkkejä: kuvien yhdisteleminen

Seuraavassa esimerkissä muodostetaan kuvia yhdistämällä pienempiä kuvia. Mitä koodi tekee ja millaisia yhdistelmiä syntyy? Päättele, ennusta ja kokeile.

val base = triangle(50, 50, Yellow)base: Pic = triangle-shape
val circles = (1 to 255).map( n => circle(n, Color(n, 0, 255)) )circles: IndexedSeq[Pic] = Vector(circle-shape, circle-shape, circle-shape, circle-shape, circle-shape, [...])
val artwork1 = circles.foldLeft(base)( _.onto(_) )artwork1: Pic = combined pic

val artwork2 = (1 to 50).foldLeft(circle(50, Red))( (result, n) => result.leftOf(circle(n, Black)) )artwork2: Pic = combined pic

Ja ehkä muistat vielä placeStar-funktion, jonka toteutit Stars-projektiin luvussa 4.4 ja joka asettelee yhden tähden taivasta vasten? Asiasta ei silloin ollut puhetta, mutta Stars-projektiin valmiiksi kirjoitettu koodi muodostaa koko tähtitaivaan kuvan nimenomaan foldLeft-käskyllä, joka toistuvasti kutsuu laatimaasi funktiota näin:

def create(skyData: StarMap, bgSize: Int) = {
  val darkSky = rectangle(bgSize, bgSize, Black)
  skyData.stars.foldLeft(darkSky)(placeStar)
}

Vielä abstraktiotasoista

Pikkutehtäviä: foldLeft

Nämä viisi kohtaa sijoittuvat tasolle C. Niiden tekeminen ei ole kurssin jatkon kannalta ratkaisevaa, mutta voi olla opettavaista.

Kysymys 1

Tässä ja kahdessa seuraavassa kohdassa oletetaan, että numbers-muuttuja on tyyppiä Vector[Int] ja viittaa vektoriin, jossa on järjestyksessä kokonaisluvut 1, 2 ja 3.

Tarkastele seuraavaa lauseketta. Mikä sen arvo on? Huomioi myös merkkijonoissa olevat välilyönnit.

numbers.foldLeft("Luvut: ")( (result, next) => result + next + " " )

Mikä seuraavista on tämän lausekkeen arvo?

Tässä ja seuraavissa kysymyksissä vaihtoehtoihin on kirjoitettu lainausmerkit ympärille, jotta välilyönnit erottuisivat paremmin. Lainausmerkit eivät sisälly lausekkeen arvona olevaan merkkijonoon.

"Luvut: 1 2 3 "

"Luvut:  1 2 3 "

"Luvut:  1 2 3"

ei mikään edellisistä

Kysymys 2

Entä tämän lausekkeen arvo?

numbers.foldLeft("Luvut: ")( _ + _ + " " )

"Luvut: 1 2 3 "

"Luvut:  1 2 3 "

"Luvut:  1 2 3"

ei mikään edellisistä

Kysymys 3

Tässä vielä yksi:

numbers.foldLeft("Luvut: ")( (result, next) => result + " " + next )

"Luvut: 1 2 3 "

"Luvut:  1 2 3 "

"Luvut:  1 2 3"

ei mikään edellisistä

Kysymys 4

Tässä kohdassa oletetaan, että data on muuttuja, joka viittaa johonkin alkiokokoelmaan. Lisäksi oletetaan, että f on Int => Boolean -tyyppinen funktio.

foldLeft-käskyllä voi toteuttaa hyvin paljon erilaisia kokoelmiin liittyviä toimintoja. Toteutetaan tästä esimerkkinä forall-metodia vastaava toiminnallisuus — päteekö tietty ehto jokaiselle alkiolle? — käyttäen foldLeftiä. Tässä itu:

data.foldLeft(AAA)( (result, next) => result BBB f(next) )

Mitä kohtiin AAA ja BBB pitäisi kirjoittaa, jotta lauseke tuottaisi saman arvon kuin data.forall(f)?

false ja &&

false ja ||

true ja &&

true ja ||

ei mikään edellisistä

Kysymys 5

Kirjoita edellisen kohdan lauseke käyttäen lyhennettyä funktioliteraalia nimettyjen parametrimuuttujien sijaan. (Korvaa tässäkin AAA ja BBB oikein.)

reduceLeft-metodi

Metodi reduceLeft muistuttaa foldLeftiä kovasti. Eroina ovat:

• reduceLeftille ei erikseen tarvitse antaa alkuarvoa, vaan ensimmäisenä tuloksena käytetään kokoelman ensimmäistä alkiota.
• reduceLeft ei toimi tyhjälle kokoelmalle lainkaan, vaan aiheuttaa ajonaikaisen virhetilanteen, jos sitä kutsutaan tyhjälle kokoelmalle.
• reduceLeftin palauttama lopputulos on (ja välituloksetkin ovat) aina samaa tyyppiä kuin kokoelman alkiotkin.

Käytetään kokeeksi reduceLeft-metodia pienimmän alkion selvittämiseen:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.reduceLeft( min(_, _) )res7: Int: -20

Tai vielä lyhyemmin:

luvut.reduceLeft(min)res8: Int: -20

reduceLeft on kätevä silloin, jos 1) voidaan olettaa, että kokoelmassa on ainakin yksi alkio, ja 2) yksialkioisen kokoelman tapauksessa tulokseksi kelpaa kokoelman ainoa alkio sellaisenaan.

Tässä lisäesimerkki kuvilla:

val kuvat = Vector(Pic("face.png"), Pic("horse.png"), Pic("obstacle.png"))kuvat: Vector[Pic] = Vector(face.png, glider.png, obstacle.png)
val allekkain = kuvat.reduceLeft( _.above(_) )allekkain: Pic = combined pic

Termeistä

Verbin fold käyttö juontuu siitä, että kyse on ikään kuin kokoelman sisältämien arvojen rimpsun "taittelemisesta" kasaan yhdeksi lopputulokseksi. Sana left liittyy siihen, missä järjestyksessä metodi käy alkiot läpi: foldLeft aloittaa läpikäynnin "vasemmalta" eli kokoelman alusta ja etenee vaiheittain "oikealle".

Tehtävä: selvitä, mitä tekevät Scalan metodit foldRight ja reduceRight.

reduceLeft plus Option — ja favorite taas

Yllä todettiin reduceLeft-metodin rajoitukseksi se, että kokoelmassa tulisi olla ainakin yksi alkio, koska muuten tulosta ei ole määritelty.

Toisaalta olet jo oppinut käyttämään Option-luokkaa kuvaamaan tilanteita, joissa jokin tulos joko on tai ei ole olemassa.

Nämä ajatukset voi yhdistää: olkoon tulos None, jos alkioita ei ole ja muussa tapauksessa sovelletaan reduceLeftiä ja kääritään sen palautusarvo Some-kääreeseen.

Kokeillaan tätä palaamalla vielä GoodStuff-projektin Category-luokkaan ja sen suosikkikirjanpitoon, josta on esitetty versioita luvuissa 4.3 ja 5.5. Tässä taas yksi versio:

def favorite =
  if (this.experiences.isEmpty) None else Some(this.experiences.reduceLeft( _.chooseBetter(_) ))

Ilman if-käskyllä toteutettua tarkistusta reduceLeft aiheuttaisi ajonaikaisen virhetilanteen (vrt. luvun 4.2 NullPointerException).

Tarve yhdistää reduceLeft-kutsu ja Option-kääre on sen verran yleinen, että tarkoitukseen on tehty oma metodinsa. Varsin näppärä toteutus favorite-metodille syntyy tätä reduceLeftOption-metodia käyttämällä:

def favorite = this.experiences.reduceLeftOption( _.chooseBetter(_) )

Tämä on käytännössä lyhennysmerkintä edelliselle versiolle, jossa käytettiin ifiä, Optionia ja reduceLeftiä erikseen.

Vapaaehtoinen lisätehtävä: MapReduce

Tässä ja edellisessä luvussa ovat esiintyneet map- ja reduce- nimiset metodit, jotka muiden esiteltyjen ohella ovat tyypillisiä funktionaaliselle ohjelmointitavalle (mistä lisää luvussa 10.2).

Selvitä ainakin pääpiirteissään, mikä on MapReduce-ohjelmointitapa, jota mm. Google-yhtiö on käyttänyt valtavien datamäärien käsittelyyn, ja mikä on sen yhteys kohtaamiimme kokoelmankäsittelymetodeihin.

Tehtävä: Election-ratkaisua uusiksi (osa 2/2)

Edellisessä luvussa 6.3 uudistit pari District-luokan metodia. Uudista nyt kaksi lisää: totalVotes-nimiset metodit. Toteuta ne silmukan sijaan käyttämällä joko foldLeftiä tai map- ja sum-metodeita. Tai mieluiten mieti vaikka molemmat toteutustavat.

Jos teit taannoin kuten luvussa 5.6 ehdotettiin ja laadit totalVoteseille avuksi countVotes-metodin, niin kohdista muutos siihen.

District-luokasta edelleen puuttumaan jäävät metodit toteutetaan aikanaan luvussa 9.2.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

FlappyBug-tehtävä (osa 17/17: koodia siistimmäksi)

Tutkikaamme myös FlappyBug-projektiin luvussa 5.6 toteutettuja metodeja sillä silmällä, miten niitä voisi uudistaa korkeamman asteen metodeilla.

Tehtävänanto

Uudista seuraavat metodit. Metodien tulee tehdä sama kuin ennen, mutta yksinkertaista toteutuksia korvaamalla for-silmukat korkeamman asteen metodikutsuilla. Voit ottaa pohjaksi oman aiemman ratkaisusi tai taannoisen esimerkkiratkaisun.

1. timePasses luokasta Game. Käytä foreach-metodia (luku 6.3).
2. isLost samasta luokasta. Toteutus yksinkertaistuu huomattavasti luvun 6.3 esittelemällä metodilla, jolla voit nimensä mukaisesti suoraan tutkia, onko ehdon toteuttavaa estettä olemassa.
3. Käyttöliittymän makePic-metodi. Korvaa silmukka foldLeft-metodikutsulla, joka sijoittaa kunkin esteen paikoilleen.

Palauttaminen

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Jälkihuomio 1: abstraktiotasoista

Edellisen luvun 6.3 Snake-tehtävässä pärjäsit placeCopies-metodilla, koska kaikki madon segmentit piirrettiin samannäköisinä. Käytössäsi oli siis korkean abstraktiotason työkalu, joka hoiti homman.

Äskeisessä tehtävässä taas toivottavasti käytit makePiciin foldLeftiä, kuten pyydettiin. placeCopies ei olisikaan kelvannut, koska esteiden kuvat eivät olleet keskenään identtisiä; valmiin työkalun puuttuessa turvauduit matalamman abstraktiotason yleiskäyttöisempään työkalustoon.

Jos o1-kirjasto ei olisi sattunut tarjoamaan placeCopies-metodia, niin myös matotehtävän olisi toki voinut ratkaista myös foldLeftillä. (Kokeile, jos haluat.)

Itse asiassa kirjaston ohjelmakoodissa placeCopies on toteutettu nimenomaan foldLeftillä, joten epäsuorasti käytit sitä joka tapauksessa.

Jälkihuomio 2: jatkoa tehokkuuspohdinnoille

Käytit toivottavasti isLost-metodissa exists-metodia (tai kenties forallia).

Luvun 5.6 vapaaehtoisessa osiossa pohdittiin tehokkuutta: tekikö vanha versio periaatteessa turhaa työtä käymällä koko vektorin läpi vaikka olikin jo löytynyt ehdon täyttävä este?

exists ja forall keskeyttävät läpikäynnin, kun palautusarvo on selvillä, joten niiden käyttäminen on yksi tapa välttää tuo (tässä mitätön ja vain periaatteellinen) tehokkuusongelma.

Emme palaa FlappyBugin pariin enää kurssin pisteytettyjen tehtävien puitteissa, mutta voit itse kehitellä peliä pidemmälle, jos haluat.

Kokoelmametodien yhdistelyä

Ohjelmia kirjoittaessa tulee usein vastaan tilanteita, joissa on hyödyksi yhdistellä kokoelmien metodeita. Tulet näkemään tästä monia esimerkkejä jo tälläkin kurssilla.

Tässä yksi pikkuesimerkki lukuvektorilla. Seuraava käsky laskee sellaisten positiivisten alkioiden lukumäärän, joiden toinen potenssi on parillinen:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.filter( _ > 0 ).map( n => n * n ).count( _ % 2 == 0 )res9: Int = 2

Seuraava pikkutehtävä tarkastelee metodien yhdistelemistä yleisemmällä tasolla:

Oletetaan, että data-niminen muuttuja viittaa johonkin kokoelmaan. Seuraava koodi käsittelee tätä kokoelmaa silmukan, if-käskyjen ja var-muuttujan avulla ja raportoi erään tuloksen. Koodissa käytetään apuna funktioita p, q ja r, jotka voivat olla mitä tahansa tyypiltään sopivia vaikutuksettomia funktioita.

var result = false
for (element <- data) {
  if (p(element)) {
    val temp = q(element)
    if (r(temp)) {
      result = true
    }
  }
}
println(result)

Tarkastele nyt seuraavaa funktionaalisella tyylillä kirjoitettua koodia, josta puuttuu muutama ratkaisevan tärkeä kohta:

println(data.AAA(p).BBB(q).CCC(r))

Mitä metodeita pitäisi kutsua kohdissa AAA, BBB ja CCC, jotta tämä (huomattavasti lyhyempi ja yksinkertaisempi!) koodinpätkä tekisi saman asian kuin ylempänä oleva? Keksitkö itse jonkin käytännöllisemmän esimerkin, jossa tällaista koodinpätkää voisi soveltaa?

Kysymys 1

AAA pitäisi korvata tällä:

exists

filter

flatMap

forall

foreach

map

Kysymys 2

BBB pitäisi korvata tällä:

exists

filter

flatMap

forall

foreach

map

Kysymys 3

CCC pitäisi korvata tällä:

exists

filter

flatMap

forall

foreach

map

Noista imperatiivisen muodon muuttaminen funktionaaliseksi -tehtävistä [kuten äskeisessä] käy kyllä hyvin ilmi, miten tuollainen [alkuperäisen silmukkakoodin] sekoitus eri konditionaalioperaattoreita onnistuu sekoittamaan pään. Tuo on varmaan juuri sitä mihin funktionaalisten metodeiden verbien sanallisuus auttaa.

Sadetehtävä

Johdanto

Kuvitellaan, että käytössä on mittari, joka tuottaa Vector[Int]-muotoisia raportteja sademääristä seuraavasti:

• Vektorissa esiintyvät nollat ja positiiviset kokonaisluvut edustavat sademäärämittausten tuloksia.
• Vektoriin voi olla tallennettuna yksi tai useampia mittausjaksoja. Kunkin jakson lopuksi siellä on erikoisarvo 999999, joka ei ole mittausdataa vaan ainoastaan ilmaisee jakson päättyvän.
• Lisäksi vektorissa voi olla negatiivisia lukuja, jotka ovat muuta dataa eivätkä kerro sademääristä.

Tehtävänanto

Laadi HigherOrder-projektin tiedostoon rainfall.scala funktio averageRainfall, joka vastaanottaa ainoaksi parametrikseen kuvatunlaisen lukuvektorin. Funktio palauttaa keskimääräisen sademäärän laskettuna ensimmäisestä parametrivektorissa esiintyvästä mittausjaksosta. Funktion on toimittava seuraavien esimerkkien mukaisesti.

import o1.rainfall._import o1.rainfall._
averageRainfall(Vector(40, 0, 50, 999999))res10: Option[Int] = Some(30)
averageRainfall(Vector(0, 0, 0, 0, 999999))res11: Option[Int] = Some(0)
averageRainfall(Vector(999999))res12: Option[Int] = None

Keskiarvo tulee palauttaa Optioniin käärittynä, Int-tyyppisenä.

Luku 999999 vain päättää mittausjakson, eikä sitä lasketa mukaan keskiarvoon. Keskiarvo lasketaan sitä edeltävistä luvuista.

Jos mittaustuloksia ei ole, ei keskiarvoakaan voi laskea.

Jos vektorissa on useita mittausjaksoja, vain ensimmäinen huomioidaan:

averageRainfall(Vector(50, 150, 100, 100, 999999, 20, 30, 90, 999999, 0, 0, 999999))res13: Option[Int] = Some(100)
averageRainfall(Vector(999999, 50, 100, 999999))res14: Option[Int] = None

Keskiarvo lasketaan vain ensimmäisestä jaksosta.

Ensimmäistä 999999:ää seuraavilla luvuilla ei ole merkitystä.

Jos ensimmäisessä jaksossa ei ole mittaustuloksia, ei saada tulosta.

Negatiiviset arvot eivät saa vaikuttaa tulokseen lainkaan:

averageRainfall(Vector(-10, 50, -100, 150, -1, -5, 100, 100, 999999, 20, 30, 90, 999999, 0, 0, 999999))res15: Option[Int] = Some(100)
averageRainfall(Vector(-100, -5, -10, 999999, 50, 100, 999999))res16: Option[Int] = None

Ohjeita ja vinkkejä

• Tavallinen kokonaislukujen jakolasku (luku 1.3) riittää tässä. Älä ryhdy pyöristämään "oikein".
• Käytä korkeamman asteen metodeita. Vaihtoehtoja on monia. Mitä erilaisia ratkaisutapoja keksit?
  • Voit vertailun vuoksi tehdä myös silmukoihin ja if-käskyihin perustuvan ratkaisun. Kummanlainen ratkaisu ilmaisee ohjelman tarkoituksen paremmin?
• Voit olettaa, että syötevektori päättyy aina lukuun 999999.

Palauttaminen

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Kuivuustehtävä

Tehtävänanto

Toteuta samaan tiedostoon myös funktio drySpell, joka:

• ottaa ensimmäisenä parametrinaan samanlaisen sadetietovektorin kuin averageRainfall;
• ottaa toisena parametrinaan positiivisen kokonaisluvun length, joka kertoo etsittävän "kuivan kauden" pituuden;
• etsii vektorista ensimmäisen sellaisen pätkän, jossa vähintään length peräkkäistä alkiota ovat suuruudeltaan välillä 0–5;
• palauttaa löydetyn kuivan kauden ensimmäisen indeksin (jos löytyi), tai negatiivisen luvun (jos ei löytynyt); ja
• huomioi kaikki mittausjaksot ja kaikki vektorin sisältämät luvut. Kuitenkaan kuiva kausi ei voi ulottua mittausjakson rajana toimivan luvun 999999 molemmille puolille. Myös negatiivinen luku katkaisee kuivan kauden.

Esimerkki:

val exampleData = Vector(10, 0, 3, 999999, 2, -10, 0, 0, 2, 1, 20, 1, 0, 1, 999999)exampleData: Vector[Int] = Vector(10, 0, 3, 999999, 2, -10, 0, 0, 2, 1, 20, 1, 0, 1, 999999)
drySpell(exampleData, 3)res17: Int = 6

Kun etsitään vähintään kolmen mittauksen keskeytymätöntä kuivaa kautta...

... ensimmäinen sellainen löytyy indeksiltä kuusi.

Ohjeita ja vinkkejä

Käytä jo esiteltyjä kokoelmametodeita. Opettele lisäksi nämä ja hyödynnä:

• indexWhere etsii ensimmäisen alkion, joka täyttää annetun ehdon. Esimerkkejä:

  val kokeilu = Vector(10, 5, 0, 3, 0, 100, 50)kokeilu: Vector[Int] = Vector(10, 5, 0, 3, 0, 100, 50)
  kokeilu.indexWhere( _ <= 0 )res18: Int = 2
  kokeilu.indexWhere( _ < 0 )res19: Int = -1
  

• sliding tuottaa tietyn mittaisia pätkiä alkuperäisestä kokoelmasta. Esimerkkejä:

  kokeilu.sliding(4).foreach(println)Vector(10, 5, 0, 3)
  Vector(5, 0, 3, 0)
  Vector(0, 3, 0, 100)
  Vector(3, 0, 100, 50)
  kokeilu.sliding(5).foreach(println)Vector(10, 5, 0, 3, 0)
  Vector(5, 0, 3, 0, 100)
  Vector(0, 3, 0, 100, 50)
  kokeilu.sliding(5).toVectorres20: Vector[Vector[Int]] = Vector(Vector(10, 5, 0, 3, 0), Vector(5, 0, 3, 0, 100), Vector(0, 3, 0, 100, 50))
  

  Tarkemmin sanoen slidingin palauttama "luettelo pätkiä" on ns. iteraattori, jolla voi käydä tietyt kokoelman pätkät kerran(!) läpi. Iteraattorille voi kutsua monia tuttuja kokoelmametodeita kuten foreach, toVector ja indexWhere. Jos haluat käsitellä kokoelman pätkiä usealla eri metodilla, voit kopioida pätkät esim. vektoriin. (Tässä tehtävässä se ei tosin ole välttämätöntä.)

Palauttaminen

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Pohdintatehtäviä

Päätämme luvun parilla pulmalla, joissa tutkit annettuja Scala-koodeja ja arvioit miten ne toimivat, jos toimivat. Tehtävien kautta nousee esiin ohjelmointitekniikoita, joista on kasvavassa määrin hyötyä, kun etenemme.

Seuraavat tehtävät ovat tarkoituksella sellaisia, ettei kaikkia vastauksia voi aukottomasti päätellä aiemmin esitetystä materiaalista. Toisaalta vastaukset ovat varsin järkeenkäyviä. Muista lukea palaute vääristä ja oikeista vastauksista!

Pohdinta-aihe 1: funktio funktion sisällä

Kysymys 1

Tutki näitä sinänsä merkityksettömiä esimerkkifunktioita:

object Kokeilu1 {
  def etsiIsot(vektori: Vector[Int]) = {
    def lasketaanIsoksi(luku: Int) = luku > 1000
    vektori.filter(lasketaanIsoksi)
  }
}

object Kokeilu2 {
  def juttele() = {
    import scala.io.StdIn._
    def kysyNimi() = {
      readLine("Anna nimi: ")
    }
    def tervehdys(kohde: String) = "Ave, " + kohde
    val eka = kysyNimi()
    val toka = kysyNimi()
    println(tervehdys(eka + " ja " + toka))
  }
}

Näiden kahden funktion sisään on kirjoitettu...

... def-sanalla toisia funktioita.

Mikä seuraavista väittämistä kuvaa näitä funktiomäärittelyjä?

Koodi on ihan kelvollista. Funktioiden sisään määritellyt lasketaanIsoksi, kysyNimi ja tervehdys ovat niiden paikallisia apufunktioita samaan tapaan kuin funktioilla voi olla sisällä paikallisia apumuuttujiakin.

Vain toinen esimerkeistä on kelvollinen.

Tuollaisia funktioita ei voi määritellä. Funktioiden sisäkkäisyys on lähtökohtaisesti ongelmallista. Jos funktion haluaa deffata jonnekin sisään, niin se pitää sijoittaa suoraan olion tai luokan sisään, ei toisen funktion.

Tuollaisia funktioita ei voi määritellä. Periaatteessa ajatus on järkevä, mutta Scalan säännöt estävät yrityksen.

Kysymys 2

Alla on muutama koodinpätkä arvioitavaksi. Niissä yritetään käyttää yllä määriteltyä Kokeilu1-oliota.

// Yritys 1:
println(Kokeilu1.lasketaanIsoksi(5000))

// Yritys 2:
val isot = Kokeilu1.etsiIsot(Vector(2000, 300, 5000))
println(Kokeilu1.lasketaanIsoksi(5000))

// Yritys 3:
val isot = Kokeilu1.etsiIsot(Vector(2000, 300, 5000))
println(lasketaanIsoksi(5000))

Mikä seuraavista kuvaa näitä kolmea esimerkkiä?

Mikään yrityksistä ei onnistu, koska annettu Kokeilu1-olion määrittely on virheellinen.

Mikään yrityksistä ei onnistu, koska lasketaanIsoksi on etsiIsot-funktion paikallinen funktio, eikä sitä voi kutsua kuin etsiIsot-funktion koodista. Periaate on sama kuin paikallisilla muuttujilla, joita ei voi käyttää kuin funktion omasta koodista.

Kaksi ensimmäistä yritystä toimivat. lasketaanIsoksi on määritelty Kokeilu1-olion sisällä, joten se on tuon olion metodi ja sitä voi kutsua olion nimen kautta.

Kaksi jälkimmäistä yritystä onnistuvat. Koska lasketaanIsoksi on määritelty etsiIsot-funktiossa, sitä ei voi kutsua ennen kuin etsiIsot on suoritettu.

Vain keskimmäinen yritys onnistuu. Koska lasketaanIsoksi on määritelty etsiIsot-funktiossa, sitä ei voi kutsua ennen kuin etsiIsot on suoritettu. Kutsumiseen tarvitaan olion nimeä, koska kyseessä on Kokeilu1-olion metodi.

Pohdinta-aihe 2: paikalliset muuttujat

Kysymys 1

Tässä on hieman toisenlainen versio yllä olevasta funktiosta.

def etsiIsot(vektori: Vector[Int], raja: Int) = {
  def lasketaanIsoksi(luku: Int) = luku > raja
  vektori.filter(lasketaanIsoksi)
}

Tämä funktio ottaa parametriksi rajan, jota suuremmat luvut pitäisi laskea isoiksi ja palauttaa osana tulosvektoria.

Paikallisessa funktiossa käytetään paitsi sen omaa muuttujaa luku...

... myös ympäröivän funktion muuttujaa raja.

Kysymys kuuluu: voiko noin tehdä? Voiko paikallinen funktio käyttää ympäröivässä funktiossa määriteltyjä nimiä kuten raja?

Kyllä. raja on käytettävissä koko etsiIsot-funktion koodissa, ja myös lasketaanIsoksi on osa tuota koodia.

Ei. Olisi kyllä kiva jos toimisi, mutta ei näytä toimivan.

Onneksi ei. Jos voisi, seuraisi merkittäviä ongelmia nimien kanssa.

Kysymys 2

Entäpä toinen seikka samassa ohjelmassa?

def etsiIsot(vektori: Vector[Int], raja: Int) = {
  def lasketaanIsoksi(luku: Int) = luku > raja
  vektori.filter(lasketaanIsoksi)
}

Funktiomme kutsuu vektorin filter-metodia. Vector-luokka metodeineen on määritelty ihan toisaalla. filter-metodin koodi suoritetaan omassa kehyksessään kutsupinossa.

Välitämme filter-metodilla parametriksi funktion, joka käyttää raja-muuttujaa, joka on määritelty ympäröivän funktion paikalliseksi muuttujaksi. filter-metodia ei kuitenkaan ole määritelty etsiIsot-funktion sisällä.

Toimiiko moinen?

Ei. lasketaanIsoksi ei voi käyttää etsiIsot-funktion paikallista muuttujaa. (Ks. edellinen kysymys.)

Ei. filter-metodi ei ole osa etsiIsot-funktion koodia, joten sillä ei ole pääsyä raja-muuttujaan.

Toimii. lasketaanIsoksi on määritelty etsiIsot-funktion sisällä ja voi käyttää sen raja-muuttujaa. Kun välitämme sen parametriksi filterille, filter pääsee samalla käsiksi myös raja-muuttujaan.

Muutama sana sulkeumista

def etsiIsot(vektori: Vector[Int], raja: Int) = {
  def lasketaanIsoksi(luku: Int) = luku > raja
  vektori.filter(lasketaanIsoksi)
}

Esimerkkikoodimme näyttää hyvin ymmärrettävältä: etsitään vektorista sellaisia lukuja, joiden arvo ylittää tietyn muuttujan arvon. On "luonnollista", että koodi toimii.

Asia ei kuitenkaan ole itsestäänselvä. filterhän suoritetaan omassa kutsupinon kehyksessään etsiIsot-funktiota vastaavan kehyksen päällä, eikä funktioilla ole pääsyä alempien kehysten paikallisiin muuttujiin (luku 1.8).

Vastaava yritys ei toimisikaan kaikissa ohjelmointikielissä, mutta monissa (kuten Scalassa) toimii. Miksi?

Koskapa koodi toimii, on mitä ilmeisimmin niin, että filter-funktiolle jotenkin välittyy ei vain lasketaanIsoksi-funktio sellaisenaan vaan myös pääsy raja-muuttujaan, jota tuo funktio käyttää. Tällaista funktion ja yhden tai useamman siihen kytketyn ulkopuolisen muuttujan yhdistelmää sanotaan sulkeumaksi eli klosuuriksi (closure). (Funktio "sulkee sisälleen" itsensä ulkopuolella määriteltyjä muuttujia.)

Scala-kääntäjä huolehtii sulkeuman luomisesta automaattisesti, kun käytät funktiossa muuttujia, jotka ovat määriteltyjä siinä ympäristössä, mihin funktion määrittelykin kirjoitetaan. Sulkeuman käyttö ohjelmassa onkin usein huomaamatonta ja intuitiivista.

Sulkeumat ovat eräs syy määritellä funktio toisen sisään. Esimerkiksi lasketaanIsoksi voi käyttää raja-muuttujaa juuri siksi, että se on määritelty etsiIsot-funktion sisällä, ja samasta syystä pääsy tuohon muuttujaan voidaan välittää sulkeumassa filter-metodilla.

Esimerkissämme määrittelimme nimellisen funktion lasketaanIsoksi, mutta sulkeumia syntyy myös funktioliteraaleja käyttäessä. Tässä toinen versio äskeisestä esimerkistä:

def etsiIsot(vektori: Vector[Int], raja: Int) =
  vektori.filter( _ > raja )

Välitämme filter-metodille parametriksi literaalin määrittelemän vertailufunktion.

Tarkemmin sanoen: välitämme filter-metodille sulkeuman, jonka koodi on _ > raja ja jolla on pääsy tarvitsemaansa raja-muuttujaan.

Tällainen ympäröivässä kontekstissa määritellyn muuttujan käyttö funktioliteraalissa (ja sulkeuman automaattinen muodostuminen literaalin perusteella) onkin aivan tavallista Scala-ohjelmissa.

Sulkeumista opit lisää jatkokurssilla tai omaehtoisella tiedonhaulla. Tämän kurssin puitteissa riittää tietää se, että äskeisen esimerkin kaltaista koodia voi mainiosti Scala-ohjelmaan kirjoittaa. Voit hyvin luonnolliseen tapaan käyttää kutsuvan koodin määrittelemää muuttujaa osana parametriksi välitettävän funktion ohjelmakoodia. Sulkeumille löytyy hyötykäyttöä tulevissa tehtävissä.

Lisää sisäkkäisyyttä

Paitsi että Scalassa voi määritellä funktioita sisäkkäin, niin luokkia, yksittäisolioita ja funktioita voi muutenkin laittaa joustavasti eri tavoin sisäkkäin. On mahdollista esimerkiksi määritellä luokka toisen luokan sisälle tai yksittäisolio metodin sisälle. Kokeile itse, jos huvittaa.

Yhteenvetoa

• Käteviin kokoelmia läpi käyviin metodeihin lukeutuvat edellisessä luvussa opittujen lisäksi myös erittäin yleiskäyttöiset foldLeft ja reduceLeft. Niillä voi muodostaa tulosarvon kokoelman alkioita vuoron perään työstämällä.
• Yhteen kiedottujen silmukka- ja if-rakenteiden sijaan on usein mielekkäämpää muotoilla algoritmi ketjuksi korkeamman asteen metodikutsuja, jossa yhden metodin palautusarvoon kohdistetaan seuraava operaatio vaiheittain.
• Funktion voi määritellä toisen sisään paikalliseksi funktioksi samaan tapaan kuin muuttujankin voi.
• Funktiota määritellessä voi sen ohjelmakoodissa käyttää funktion itsensä ulkopuolisia muuttujia ympäröivästä kontekstista; näin syntyvää rakennetta kutsutaan sulkeumaksi eli klosuuriksi.
• Lukuun liittyviä termejä sanastosivulla: korkeamman asteen funktio; kokoelma; abstraktiotaso; paikallinen funktio, käyttöalue; sulkeuma.

Palaute

Huomaathan, että tämä on henkilökohtainen osio! Vaikka olisit tehnyt lukuun liittyvät tehtävät parin kanssa, täytä palautelomake itse.

Ajankäyttö: (*) Pakollinen

Kirjoita alle, kuinka monta minuuttia olet käyttänyt kokonaisuudessaan oppimateriaalin tähän lukuun (materiaalin lukeminen, tehtävien tekeminen jne.). Viidentoista minuutin tai puolen tunnin tarkkuus riittää hyvin.

"Minusta tuntuu, että olen tajunnut oleellisimmat asiat tästä luvusta." (*) Pakollinen

täysin samaa mieltä

jokseenkin samaa mieltä

jokseenkin eri mieltä

täysin eri mieltä

en osaa sanoa / en kommentoi

Sanallinen kommentti tai kysymys:

Sanallinen palaute ei ole pakollista. Kysy silti mieluusti jotain, anna palautetta tai pohdiskele! (Oikea paikka kiireellisille keskeneräisen tehtävän ratkaisemiseen liittyville pyynnöille on kuitenkin Piazza tai harjoitusryhmä, sillä emme välttämättä ehdi reagoida näihin palautteisiin kierroksen ollessa auki.)

Tekijät

Tämän oppimateriaalin kehitystyössä on käytetty apuna tuhansilta opiskelijoilta kerättyä palautetta. Kiitos!

Kierrokset 1–13 ja niihin liittyvät tehtävät ja viikkokoosteet on laatinut Juha Sorva.

Kierrokset 14–20 on laatinut Otto Seppälä. Ne eivät ole julki syksyllä, mutta julkaistaan ennen kuin määräajat lähestyvät.

Liitesivut (sanasto, Scala-kooste, usein kysytyt kysymykset jne.) on kirjoittanut Juha Sorva sikäli kuin sivulla ei ole toisin mainittu.

Tehtävien automaattisen arvioinnin ovat toteuttaneet: (aakkosjärjestyksessä) Riku Autio, Nikolas Drosdek, Joonatan Honkamaa, Jaakko Kantojärvi, Niklas Kröger, Teemu Lehtinen, Strasdosky Otewa, Timi Seppälä, Teemu Sirkiä ja Aleksi Vartiainen.

Lukujen alkuja koristavat kuvat ja muut vastaavat kuvituskuvat on piirtänyt Christina Lassheikki.

Yksityiskohtaiset animaatiot Scala-ohjelmien suorituksen vaiheista ovat suunnitelleet Juha Sorva ja Teemu Sirkiä. Niiden teknisen toteutuksen ovat tehneet Teemu Sirkiä ja Riku Autio käyttäen Teemun toteuttamia Jsvee- ja Kelmu-työkaluja.

Muut diagrammit ja materiaaliin upotetut vuorovaikutteiset esitykset on laatinut Juha Sorva.

O1Library-ohjelmakirjaston ovat kehittäneet Aleksi Lukkarinen ja Juha Sorva. Useat sen keskeisistä osista tukeutuvat Aleksin SMCL-kirjastoon.

Opetustapa, jossa käytämme O1Libraryn työkaluja (kuten Pic) yksinkertaiseen graafiseen ohjelmointiin on saanut vaikutteita tekijöiden Flatt, Felleisen, Findler ja Krishnamurthi oppikirjasta How to Design Programs sekä Stephen Blochin oppikirjasta Picturing Programs.

Oppimisalusta A+ on luotu Aallon LeTech-tutkimusryhmässä pitkälti opiskelijavoimin. Pääkehittäjänä toimii tällä hetkellä Jaakko Kantojärvi, jonka lisäksi järjestelmää kehittävät useat tietotekniikan ja informaatioverkostojen opiskelijat.

Kurssin tämänhetkinen henkilökunta on kerrottu luvussa 1.1.

Lisäkiitokset tähän lukuun

Sademäärätehtävä on muunnelma Elliot Solowayn klassikkotehtävästä.

Palautusta lähetetään...

×

Identtinen palautus

Tämä palautus on identtinen aikaisemman palautuksen kanssa. Oletko varma, että haluat lähettää palautuksen?

Peruuta Lähetä