5 Perustyyppejä ja operaatioita

Muutettu viimeksi 29.2.2016 / Sivu luotu 18.3.2010 / [oppikirjan esimerkit] / [Scala]

Sivun sisältöä:

• Numeeriset tyypit
• String-tyyppi
• Symboliliteraalit
• "Operaattori == metodi"
• Olioiden samuus
• Operaattoripresedenssi
• Rikastettuja operaatioita

Numeeriset tyypit

Scalan numeeriset tyypit on Bytecode-tasolla toteutettu Javan alkeistyyppeinä, joten ohjelmien suoritustehokkuuden pitäisi säilyä Java-tasoisena.

Scalassa numeeristen tyyppien operaatiovalikoimaa on rikastettu, ks. alla.

String-tyyppi

String-literaalivakioihin on tehty kirjoitusvaivoja säästävä lisäys: kolmikertaisin lainausmerkein voi kirjoittaa "raakatekstiä":

println("""Näin voi kirjoittaa tekstiä, joka sisältää vaikkapa
           rivinvaihtoja, "- ja \-merkkejä sellaisinaan

              tyhjiä rivejä yms, yms.
           vain kolminkertaista lainausmerkkiä ei voi olla...""")

Näin voi kirjoittaa tekstiä, joka sisältää vaikkapa
           rivinvaihtoja, "- ja \-merkkejä sellaisinaan
           
              tyhjiä rivejä yms, yms.
           vain kolminkertaista lainausmerkkiä ei voi olla...

println("""|Näin voi kirjoittaa tekstiä, joka sisältää vaikkapa
           |rivinvaihtoja, "- ja \-merkkejä sellaisinaan
           |
           |   tyhjiä rivejä yms, yms.
           |vain kolminkertaista lainausmerkkiä ei voi olla...""".stripMargin)

Näin voi kirjoittaa tekstiä, joka sisältää vaikkapa
rivinvaihtoja, "- ja \-merkkejä sellaisinaan

   tyhjiä rivejä yms, yms.
vain kolminkertaista lainausmerkkiä ei voi olla...

Symboliliteraalit

Symbolit ovat, ..., hmm..., ..., no symbolit ovat symboleja:

def sanoJotain(kuka:Symbol) {
  if      (kuka=='kissa) println("Miau")
  else if (kuka=='koira) println("Hauhau")
  else                   println("Ammuu")
}

sanoJotain('possu) // Ammuu
sanoJotain('kissa) // Miau
sanoJotain('koira) // Hauhau

"Operaattori == metodi"

println(1+2)        // 3
println((1).+(2))   // 3

// nyt myös:
println(1.+(2))     // muutama versio sitten tulkittiin doubleksi

println("kukkapenkki".indexOf('p'))  // 5
println("kukkapenkki" indexOf 'p' )  // 5

Nähdyt esimerkit olivat infix-operaatioita: "operandi-operaatio-operandi". Muitakin on:

// näin kaksiparametrinen metodikutsu "infixataan":
println("kukkapenkki".indexOf('k', 4))   // 8
println("kukkapenkki" indexOf ('k', 4))  // 8

// prefix:
println(-7)         // -7
println(7.unary_-)  // -7

//postfix:
import scala.language.postfixOps // nyt tarvitaan tämä!

println("HUUDETAAN".toLowerCase) // huudetaan
println("HUUDETAAN" toLowerCase) // huudetaan

Esimerkki:

class Kissa {
  def unary_+ = "Miau"
  def unary_- = "Hyrr"
  def unary_~ = "Shhhhs"
}

val a = new Kissa
println(+a)  // Miau
println(-a)  // Hyrr
println(~a)  // Shhhhs

// myös toki tyyliin:
println(a.unary_+) // Miau

Olioiden samuus

Asiat ovat lopulta aika samoin Scalassa. Tosin kaikki arvot ovat olioita ja ==- ja !=-operaatiot testaavat equals-samuutta! Ne suorastaan itse asiassa kutsuvat equals-metodia. Siispä esimerkiksi seuraavat vertailut ovat true:

"he"+"llo" == "hello" 
List(1, 2, 3) == List(1, 2, 3)
"kukamitaha" != 3.14  // jopa siis keskenään eri tyyppisiä voi
                      // verrata dynaamisten kielten tapaan

Omiin luokkiin ohjelmoidut equals-metodit käyttäytyvät samaan tapaan:

class Otus (val nimi: String, val pituus: Int) {
  // pitäisi määritellä myös override def hashCode!
  override def equals(that: Any) = 
    that match {
      case that: Otus => this.nimi == that.nimi && this.pituus == that.pituus
      case _ => false
  }
}

val a = new Otus("Aapeli", 22)
val b = new Otus("Beepeli", 22)
val c = new Otus("Aa" + "peli", 30-8)

println(a==b)     // false
println(a==c)     // true
println(a=="kukamitaha") // false

Scalassa on toki myös oliosamuustestit, jotka ovat nimeltään eq ja ne. Siispä esimerkiksi seuraavat vertailut ovat false:

val a="he"; a+"llo" eq "hello"
List(1, 2, 3) eq List(1, 2, 3)

Operaattoripresedenssi

Scalassa asia on sikäli kiinostava, että ohjelmoija voi sydämensä kyllyydestä ohjelmoida ikiomia operaattoreitaan.

Ideana on sopia asiat tyyliin: kaikki kertomerkillä (*) alkavat operaatiot (eli metodit) sitovat tiukemmin kuin mikään yhteenlaskumerkillä (+) alkava operaatio (eli metodi). Ja vain ensimmäinen merkki merkitsee. Siis vaikkapa kaikki *-merkillä alkavat operaatiot sitovat yhtä tiukasti eli samalla tiukkuudella.

Sitovuus ensimmäisen merkin perusteella tiukimmasta löysimpään:

muut kuin alla luetellut erikoismerkit
* / %
+ -
:
= !
< >
&
^
|
kirjaimet
kaikki sijoitusoperaatiot

Huom: Kuten aiemmin jo todettiin, :-merkkiin (kaksoispiste) päättyvät operaatiot assosioituvat oikealta vasemmalle. Kaikki muut operaatiot assosioituvat tuttuun tapaan vasemmalta oikealle.

Rikastettuja operaatioita

0 max 5			5
0 min 5 		0
-2.7 abs 		2.7
-2.7 round 		-3
1.5 isInfinity 		false
(1.0 / 0) isInfinity 	true
4 to 6 			Range(4, 5, 6)
"bob" capitalize 	"Bob"
"robert" drop 2 	"bert"
...

Rikastuksia löytyy mm. luokista RichInt, RichChar, RichString, RichDouble RichBoolean. Katso Scala-API.