Helsingin yliopisto / tietojenkäsittelytieteen laitos / Ohjelmointitekniikka (Scala) / © Arto Wikla 2010

1 Johdantoa

Muutettu viimeksi 22.3.2010 / Sivu luotu 3.3.2010 / [oppikirjan esimerkit] / [Scala]

Ohjelmointikieliä on paljon, hyvin paljon. Scala on yksi uusi monien joukossa. Kielen viralliset sivut ovat osoitteessa http://www.scala-lang.org/ . Tuolta löytyy tietoa laidasta laitaan spesifikaatiosta ja APIsta aloittelijan oppaisiin.

Tämän sivun sisältöä:

Taustaa ja ominaisuuksia

Pikku ohjelman laatiminen on vaivatonta

Scala-ohjelman suorittamisen tapoja

Quicksort kahdella tyylillä

Esimerkkiominaisuuksia

Kirjan luvusta 1: A Scalable Language

Taustaa ja ominaisuuksia

Scalalla on monia kiinnostavia ominaisuuksia. Seuraavassa on pieni ja epätäydellinen luettelo joistakin kielen ominaisuuksista. Luettelossa on muutamia sivun sisäisiä linkkejä kyseisen ominaisuuden esittelyyn.

Scala on sveitsiläinen laatutuote. Kielen isä Martin Odersky, Lausannen Ecole Polytechnique Fédéralen professori, on peräti itsensä Niklaus Wirthin oppilas.
Scala on saanut nimensä skaalautuvuudestaan: kielen on määrä soveltua helppoon pienten ohjelmien tekemiseen, selkeään ja helppoon sovellusohjelmien tekemiseen, hard-core-tason funktionaaliseen ohjelmointiin, hyvin joustavaan uusien ohjelmakirjastojen luontiin, ... Esimerkiksi Scalan oma for-lause on vakiokirjastoon Scalalla ohjelmoitu väline, ei kielen perusrakenteita...
Scala on haluttaessa hyvin yksinkertainen väline. Katso esimerkki Pikku ohjelman laatiminen on vaivatonta.
Scalaa voi käyttää suoraan "laskimena", "skriptikielenä" tai tavukoodiksi kääntäen ja Javan virtuaalikoneella suorittaen. Katso esimerkki Scala-ohjelman suorittamisen tapoja
Scala on (ainakin) kaksiparadigmakieli: aito ja tyylikäs oliokieli, aito ja tyylikäs funktionaalinen kieli. Kieli on hyvin kompakti ja silti hyvin ilmaisuvoimainen. Katso esimerkki Quicksort kahdella tyylillä. Scala itse asiassa "sisältää" Lispin ja Lambda-kalkyylin. Funktiot ovat arvoja siinä kuin numeeriset arvotkin, funktioita voidaan välittää parametreina, muuttujan arvona voi olla funktio, funktio voi palauttaa arvonaan funktion, käytettävissä ovat funktioliteraalit siinä kuin numeeriset literaalitkin...
Scala on vahvasti ja staattisesti tyypitetty. Mm. tässä Scala eroaa esim. Pythonista.
Scala ei ole litteä C-kieliperheen tapaan (Javakin kuuluu litteisiin kieliin!): Scalan aliohjelmat voivat sisältää paikallisia aliohjelmia, jotka voivat sisältää paikallisia aliohjelmia, ... Scalan lohkot voivat sisältää lohkoja, jotka voivat sisältää lohkoja, ... Sisemmästä näkee ulomman tunnukset, ellei niitä ole omin tunnuksin peitetty. Ulommasta ei näe sisempien tunnuksia.
Scala on toteutettu Javan kirjastojen ja virtuaalikoneen varaan (myös Windowsin .NET-variantti on jossakin määrin olemassa). Javan koko API on käytettävissä Scalan kautta. Myös muita, vaikkapa itse tehtyjä Java-luokkia voidaan käyttää Scala-ohjelmissa.
Scalan lähdekoodi on avoin.
...

Pikku ohjelman laatiminen on vaivatonta

Scalassa kirjoitusvaivaa ja erilaisia aloittelijalle käsittämättömiä "loitsuja" on paljon vähemmän kuin Javassa. Kääntäjä ei vaadi puolipistettä, jos se muutenkin osaa päätellä ilmaisujen rajat. Jos muuttujan tyyppi selviää käyttöyhteydestä, tyyppiä ei tarvitse mainita, jne., jne.

Esimerkki 1: Ohjelma laskee syöttölukujen keskiarvon. Lukumäärä pyydetään.

Java-ratkaisu:

import java.util.Scanner;
public class Karvo {
  private static Scanner lukija = new Scanner(System.in);
  public static void main(String[] args) {

    System.out.println("Monenko luvun keskiarvo lasketaan? ");
    int lukujenLkm = lukija.nextInt();
    double lukujenSumma = 0;
    int monesko = 0;
    while (monesko < lukujenLkm) {
      monesko = monesko+1;
      System.out.print("Anna "+monesko+". luku: ");
      double luku = lukija.nextDouble();
      lukujenSumma += luku;
    }
    if (lukujenLkm <= 0)
      System.out.println("\nEi lukuja, ei keskiarvoa.\n");
    else {
      double lukujenKarvo = lukujenSumma/lukujenLkm;
      System.out.println("\nKeskiarvo on "+lukujenKarvo+".\n");
    }
  }
}

Scala-ratkaisu:

println("Monenko luvun keskiarvo lasketaan? ");
val lukujenLkm = readInt
var lukujenSumma = 0.0
var monesko = 0
while (monesko < lukujenLkm) {
  monesko = monesko+1
  print("Anna "+monesko+". luku: ")
  val luku = readDouble
  lukujenSumma += luku
}
if (lukujenLkm <= 0)
  println("\nEi lukuja, ei keskiarvoa.\n");
else {
  val lukujenKarvo = lukujenSumma/lukujenLkm;
  println("\nKeskiarvo on "+lukujenKarvo+".\n");
}

Ylläolevat rivit voidaan kirjoittaa tekstitiedostoon ja suorittaa sellaisenaan komennolla:
scala tiedosto

Java-ohjelmahan joudutaan aina ensin kääntämään tavukoodiksi ja sitten erikseen suorittamaan tulkilla.

Esimerkki 2: Myös olioiden kanssa askartelu on Javaa paljon vaivattomampaa. Seuraavassa peruskurssin "ensimmäinen olio"

Java-ratkaisu:

public class Kuulaskuri {
   private int kuu;   // sallitut arvot 1,..12
   public Kuulaskuri() {
     kuu = 1;
   }
  public int moneskoKuu() {
    return kuu;
  }
  public void seuraavaKuu() {
    ++kuu;
    if (kuu == 13)
      kuu = 1;
  }

  public static void main (String[] args){
    Kuulaskuri a = new Kuulaskuri();
    System.out.println(a.moneskoKuu());
    a.seuraavaKuu();
    System.out.println(a.moneskoKuu());
    int i = 0;
    while (i < 20) {
      a.seuraavaKuu();
      System.out.println(a.moneskoKuu());
      i += 1;
    }
  }
}

Scala-ratkaisu [varoitus: tämä on oikeastaan "Javaa Scalalla"!]:

class Kuulaskuri {
  private var kuu = 1  // sallitut arvot 1,..12
  def moneskoKuu = kuu
  def seuraavaKuu {
    kuu += 1
    if (kuu == 13)
      kuu = 1
  }
}

var a = new Kuulaskuri
println(a.moneskoKuu) // voi kirjoittaa myös println(a moneskoKuu)
a.seuraavaKuu         // voi kirjoittaa myös a seuraavakuu;
println(a moneskoKuu)
var i = 0
while (i < 20) {
  a seuraavaKuu;
  println(a moneskoKuu)
  i += 1
}

Scala-ohjelman suorittamisen tapoja

Scalaa voidaan suoraan sellaisenaan käyttää "laskimena", antaa ohjelmarivejä suoraan tulkille (komento scala) (käyttäjä kirjoittaa kehoitteen perään - mahdollisesti useita rivejä, jos rakenne on monirivinen - Scala vastaa ilman rivin aloitinmerkkiä; nuo "res n":t ovat arvoille generoituja tunnuksia). Tässä yksi istunto:
scala> 1+2 res0: Int = 3 scala> println("Hoi maailma!") Hoi maailma! scala> var a=5 a: Int = 5 scala> while (a>0) { | println(a) | a=a-1 | } 5 4 3 2 1 scala> def neliösumma(a:int, b:Int)= | a*a+b*b neliösumma: (int,Int)Int scala> neliösumma(3,4) res3: Int = 25 scala> exit
Kielen ilmauksia voidaan sellaisinaan kirjoittaa teksitiedostoksi, joka suoritetaan ilmauksella scala tiedostonimi. Tällä tavoin käytettynä Scalaa voitaisiin kutsua "skriptikieleksi". Esimerkkinä tiedosto tervehdi.ohjelma:
```
println("Montako tervehdystä?")
var lkm = readInt
while (lkm>0) {
  println("Hoi maailma!")
  lkm = lkm-1
}
```
Suoritus komennolla
scala tervehdi.ohjelma
Scala-ohjelma voidaan kääntää Javan tavukoodiksi Java-virtuaalikoneella suoritettavaksi. Nyt tarvitaan pääohjelma, jotta virtuaalikone tietäisi, ketä kutsua. Scalassa ei ole "static"-kalustoa; sellaisen vastineena käytetään ns. singleton-olioita (eli "ainokaisia" Koskimiehen Kaitsun käännöksenä). Syntaksi on yksikertainen ja luonteva. Äskeinen ohjelma on muokattava muotoon
```
object tervehdi {
  def main(args: Array[String]) = {
    println("Montako tervehdystä?")
    var lkm = readInt
    while (lkm>0) {
      println("Hoi maailma!")
      lkm = lkm-1
    }
  }
}
```
Ohjelma Javan tapaan käännetään ensin tavukoodiksi
scalac tervehdi.scala
ja myös suoritetaan Javan tapaan komennolla
scala tervehdi
Scalan "skripti" voidaan helposti muuttaa myös Linuxin tai Windowsin komentotulkille annettavaksi skriptiksi. Esimerkkinä edellä nähty esimerkki Linuxin skriptinä:
```
#!/usr/bin/env scala
!#

println("Montako tervehdystä?")
var lkm = readInt
while (lkm>0) {
  println("Hoi maailma!")
  lkm = lkm-1
}
```
Ohjelma käynnistyy yksinkertaisesti tiedostonimellä. Suoritusoikeus tiedostolle on luonnollisesti annettava. Jos Linuxissa turvallisuussyistä "työhakemisto ei ole hakupolulla", käynnistyksessä tiedostonimen eteen pitää kirjoittaa "./" Koko istunnon ajaksi "työhakemiston voi lisätä hakupolkuun" komennolla "PATH="$PATH:.". Jos tuon komennon lisää ~/.bashrc:hen (ei-login-shellit) ja ~/.bash_profile:en (login-shellit) "työhakemisto on hakupolulla" oletusarvoisesti.

Quicksort kahdella tyylillä

Pikajärjestäminen voidaan ohjelmoida tavalliseen algoritmiseen ("proseduraaliseen") tapaan:
```
def sort(xs: Array[Int]) {
  def swap(i: Int, j: Int) {
    val t = xs(i); xs(i) = xs(j); xs(j) = t
  }
  def sort1(l: Int, r: Int) {
    val pivot = xs((l + r) / 2)
    var i = l; var j = r
    while (i <= j) {
      while (xs(i) < pivot) i += 1
      while (xs(j) > pivot) j -= 1
      if (i <= j) {
        swap(i, j)
        i += 1
        j -= 1
      }
    }
    if (l < j) sort1(l, j)
    if (j < r) sort1(i, r)
  }
  sort1(0, xs.length - 1)
}
```
Tässä huomiota kannattaa kiinnittää mm. siihen, miten Scala Algolin ja Pascalin tapaan sallii sisäkkäiset aliohjelmat meille vanhemmille tutuin näkyvyyssännöin ;-). C-pohjaisissa kielissä - Java mukaan lukien! - aliohjelmarakenne on "litteä": niissä aliohjelma ei voi sisältää omia "pikku apulaisiaan" Algolin ja Pascalin tapaan!
Taulukon indeksoinnissa Scala käyttää kaarisulkeita tuttujen hakasulkeiden síjaan.
Myös funktionaalinen tyyli Scalalla sujuu:
```
def sort(xs: Array[Int]): Array[Int] =
  if (xs.length <= 1) xs
  else {
    val pivot = xs(xs.length / 2)
    Array.concat(
      sort(xs filter (pivot >)),
      xs filter (pivot ==),
      sort(xs filter (pivot <))
    )
}
```
Tässä huomio kannattaa kiinnittää muutamaan seikkaan: Array.concat liittää yhteen kolme osataulukkoa. ensimmäiseen suodatetaan kaikki jakoalkiota pienemmät alkiot, keskimmäiseen jakoalkion kanssa yhtä suuret ja kolmanteen suuremmat. Suodattimelle (filter) annetaan argumenttina ns. predikaattifunktio tyyliin "pivot >", mikä todellakin tarkoittaa sitä, että vertailun operaatio annetaan parametrina. Scalassa funktiot ovat arvoja siinä kuin numeeriset arvotkin, funktioita voidaan välittää parametreina, muuttujan arvona voi olla funktio, funktio voi palauttaa arvonaan funktion, käytettävissä ovat funktioliteraalit siinä kuin numeeriset literaalitkin...

Esimerkkiominaisuuksia

for-lauseella on näppärä syntaksi. Luodaan ensin taulukko

  var a = new Array[Int](4)
  a(0) = 4
  a(1) = 3
  a(2) = 8
  a(3) = 1

Alkiot voidaan käydä läpi indeksoiden tai "for each" -tyyliin:

  for (i <- 0 to 3)
    println(a(i))

  for (e <- a)  // "foreach"!
    println(e)

Aivan vastavalla tavalla voidaan käsitellä listoja:

  val a = List(4, 3, 8, 1)

  for (i <- 0 to 3)
    println(a(i))

  for (i <- a)  // "foreach"!
    println(i)

Funktiot parametreina:

// määritellään pari funktiota ja luodaan lista:

def muotoile(muotoilija: String => String, sanat: List[String]) =
  for(sana <- sanat)
     print(muotoilija(sana))

def huuda(x: String) = x.toUpperCase

val lista = List("hip ", "hurraa!")

// annetaan parametrina ensin nimetty funktio ja lista:
muotoile(huuda, lista)
println

// tulostus: HIP HURRAA!

// annetaan sitten parametrina funktioliteraali ja lista:
muotoile({x => x.replace('h', 'j')}, lista)
println

// tulostus: jip jurraa!

// tässä tilanteessa edes aaltosulkeet eivät ole välttämättömiä:
muotoile(x => x.replace('h', 'B'), lista)
println

// tulostus: Bip Burraa!

Esimerkissä siis funktion muotoile muodollinen funktioparametri määriteltiin muodossa: muotoilija: String => String ja vastaavina todellisina parametreina käytettiin nimettyä funktiota huuda ja funktioliteraalia {x => x.replace('h', 'j')}.

Ohjelmoinnin perusteet -kurssin Pikkuvarasto-esimerkki Scalalla [varoitus: tämä on oikeastaan "Javaa Scalalla"!]:

class Pikkuvarasto (private var määrä: Double, val tuote: String) {

  def this() = this(0.0, "(nimetön)")  // parametriton konstruktori oletusarvoin

  def paljonkoOn = määrä // aksessori on tehtävä koska määrä on private!

  def vieVarastoon(paljonko: Double) = if (paljonko > 0) määrä += paljonko

  def otaVarastosta(paljonko: Double) =
    if (paljonko <= 0)  0.0
    else if (paljonko <= määrä) {määrä -= paljonko;  paljonko;}
    else {val saatiin = määrä; määrä = 0; saatiin;}

  override def toString =  "("+tuote+": "+määrä+")"

  def summa(toinen: Pikkuvarasto) =
    new Pikkuvarasto(määrä + toinen.määrä, tuote + toinen.tuote);
}

Huomioita:

Pääkonstruktorin muodolliset parametrit siis annetaan otsikossa. Jos ei kirjoiteta määrettä var eikä val, saadaan vastaava privaatti vakiokenttä. Jos kirjoitetaan määre var, saadaan julkinen muutettava kenttä. Jos käytetään määrettä val, saadaan julkinen vakiokenttä. Määreellä private var saadaan Java-tyylin kaltainen privaatti muutettava kenttä, jolle voi itse ohjelmoida haluamansa aksessorit.
Toissijaisia (kuormittavia) konstuktoreita ohjelmoidaan pääkonstruktorin avulla: def this(...) = this(...).
Perityn piirteen korvaamisessa on pakko käyttää määrettä override. Erinomainen ominaisuus: Näin ei tule vahingossa korvanneeksi ((override) kun tarkoitus oli kuormittaa (overload)!

// Pikkuvaraston kokeilua Java-esimerkin tapaan:

val mehua =  new Pikkuvarasto(10, "Mehu")
val olutta = new Pikkuvarasto(123.4, "Olut")
val bensaa = new Pikkuvarasto(90.1, "Bensa")
println(mehua); println(olutta); println(bensaa)

val a = new Pikkuvarasto(); println(a)

val b = mehua; println("" + b + mehua)
b vieVarastoon(25); println("" + b + mehua)

println("Muuttuja bensaa:" + bensaa + ", määrä=" + bensaa.paljonkoOn +
        ", nimi=" + bensaa.tuote)

println(bensaa)
bensaa.vieVarastoon(27.4); println(bensaa)
bensaa.vieVarastoon(-34.1); println(bensaa)

println(olutta)
var saatiin: Double  = olutta.otaVarastosta(10.2)
println("Saatiin " + saatiin + ", tilanne: "+olutta)
saatiin = olutta.otaVarastosta(-78.8)
println("Saatiin " + saatiin + ", tilanne: "+olutta)
saatiin = olutta.otaVarastosta(175.5)
println("Saatiin " + saatiin + ", tilanne: "+olutta)

olutta.vieVarastoon(432.1)
val c = mehua.summa(olutta)
println("" + mehua + olutta + c)

var d = c.summa(bensaa); println("" + c + bensaa + d)

d = d.summa(bensaa.summa(mehua)); println(d)

Kirjan luvusta 1: A Scalable Language

Oppikirjan esimerkejä luvusta 1 kommentoituna ja laajennettuna:

Asiat voivat olla helppoja:

  var capital = Map("US" -> "Washington", "France" -> "Paris")
  capital += ("Japan" -> "Tokyo")
  println(capital("France"))   // Paris

  var pk =  Map("Suomi" -> "Helsinki", "Ruotsi" -> "Tukholma")
  println(pk("Ruotsi"))  // Tukholma

  println(pk)  // Map(Suomi -> Helsinki, Ruotsi -> Tukholma)
  println(pk + ("Viro" -> "Tallinna"))  // Map(Suomi -> Helsinki, Ruotsi -> Tukholma, Viro -> Tallinna)
  println(pk - ("Ruotsi"))  // Map(Suomi -> Helsinki)

Helppoa ja hauskaa. Näyttää vaarattomalta, mutta sisältää itse asiassa mielenkiintoisia juttuja:

Mitä itse asiassa tarkoittaa tuo ...=Map(...)? Ei ole konstruktori, ei! [http://www.scala-lang.org/docu/files/api/index.html, Ks. scala.collection.immutable, trait Map. Objektissa Map on apply-metodi...]
Assosiaatiotaulu Map ei ole kielen syntaksia, kuten vaikkapa Perlissä, Pythonissa ja Rubyssä. Map on Scalassa kirjastoon ohjelmoitu väline, jota voi itsekin muokata.
Näkyy ynnälasku ja vähennyslasku olevan monipuolista... Operaattoreita ei kuormiteta a'la C++, ei toki! Operaattorilta näyttävät otukset ovatkin itse asiassa metodeja...

Omat tyypit ja operaatiot:

Scalassa BigInt on kirjastossa. Vastaa Javan BigInteger-luokkaa (itse asiassa "wräppää" tuon luokan. Kyseessä siis on kooltaan rajoittamaton kokonaislukutyyppi. Mutta ero löytyy helppokäyttöisyydessä.

Scalalla voi ohjelmoida seuraavasti:

  def factorial(x: BigInt): BigInt = 
    if (x == 0) 1 else x * factorial(x - 1)

  println(factorial(30))  // 265252859812191058636308480000000

Toki Javan luokkaakin voi käyttää, mutta, mutta:

  import java.math.BigInteger
  def factorial(x: BigInteger): BigInteger =
    if (x == BigInteger.ZERO)
      BigInteger.ONE
    else
      x.multiply(factorial(x.subtract(BigInteger.ONE)))

  println(factorial(new BigInteger("30")))  // 265252859812191058636308480000000

Luokka BigInt nyt vaan sattuu olemaan Scalan standardikirjastossa. Ja sille nyt vaan sattuu olevan ohjelmoitu mm. metodit +, -, *, ... Ja toki metodikutsun saa kirjoittaa esim. Javasta tuttuun tapaan:

  def factorial(x: BigInt): BigInt =
    if (x == 0) 1 else x.*(factorial(x - 1))

Myös molemmat:

  def factorial(x: BigInt): BigInt =
    if (x == 0) 1 else x.*(factorial(x.-(1)))

Ja toki yhtäsuuruusvertailun voi tehdä toisinkin

  def factorial(x: BigInt): BigInt =
    if (x.equals(0)) 1 else x.*(factorial(x.-(1)))

Vielä kerran: BigInt siis ei ole kieleen sisäänrakennettu tyyppi vaan kirjastoon ohjelmoitu tyyppi. Vastaavia voi siis tehdä myös itse!

Kontrollirakenteetkin voivat olla kirjastorutiineita:

Esimerkkinä Scalan kirjastosta ns. aktorimalli rinnakkaisohjelmointiin. Aktori osaa lähettää ja vastaanottaa viestejä muiden aktoreiden kanssa. Se ei jaa yhteistä muistia muiden aktoreiden kanssa. Viesti lähetetään !-operaatiolla:

  vastaanottaja ! viesti

Operaation jälkeen viestin lähettäjän toiminta jatkuu välittömästi, so. ei odotella kuittausta.

Jokaisella aktorilla on postilaatikko, johon aktorin saamat viestit tulevat jonottamaan. Postilaatikon viestit vastaanotetaan receive-operaatiolla:

  receive {
    case Msg1 => ... // handle Msg1
    case Msg2 => ... // handle Msg2
    // ...
  }

receive-lohko sisältää "message pattern" -ehtoja. Postilaatikosta valitaan vanhin sellainen viesti, johon täsmää jokin lohkon ehto, ja tuohon ehtoon liittyvä operaatio suoritetaan. Jos laatikko on tyhjä tai jos mikään laatikon viesteistä ei täsmää yhteenkään ehtoon, odotellaan...

Aktoreita kirjoitellaan tyyliin:

  actor { 
    var sum = 0
    loop {
      receive {
        case Data(bytes)       => sum += hash(bytes)
        case GetSum(requester) => requester ! sum
      }
    }
  }

Oleellista tässä on, ettei yksikään nimistä actor, loop, receive, tai operaatio "!" ole Scala-kieleen sisäänrakennettu. Ne kaikki ovat (taas kerran!) kirjastoon ohjelmoituja välineitä. (Esim. Erlang-kielessä - josta aktorit ovat kotoisin - ne ovat varattuja sanoja ja sisäänrakennettuja operaatioita.)

Ja siis taas kerran: Tällaisia siis voi tehdä myös itse.