2 Alkeita: tulkki ja lauseita

Muutettu viimeksi 23.2.2016 / Sivu luotu 9.3.2010 / [oppikirjan esimerkit] / [Scala]

Sivun sisältöä:

• Tulkissa
• Komentoriviparametri skriptissä
• Valintaa ja toistoa, funktioparametreja

Tulkissa

$ scala
Welcome to Scala version 2.11.5 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_72).
Type in expressions to have them evaluated.
Type :help for more information.

scala> 1 + 2
res0: Int = 3
scala> res0 * 3
res1: Int = 9

scala> println("Hello, world!")
Hello, world!

scala> val msg = "Hello, world!"
msg: java.lang.String = Hello, world!

scala> val msg2: java.lang.String = "Hello again, world!"
msg2: java.lang.String = Hello again, world!

scala>  println(msg)
Hello, world!

scala> msg = "Goodbye cruel world!"

<console>:5: error: reassignment to val
       msg = "Goodbye cruel world!"
           ^

scala> var muu = 666
muu: Int = 666

scala> println(muu)
666

scala> muu = 14
muu: Int = 14

scala> println(muu)
14

scala> val multiLine =
     | "This is the next line."
multiLine: java.lang.String = This is the next line.

scala> def max(x: Int, y: Int): Int = {
     | if (x > y) x
     | else y
     | }
max: (x: Int, y: Int)Int

scala> def max2(x: Int, y: Int) = if (x > y) x else y
max2: (x: Int, y: Int)Int

scala> max(3, 5)
res5: Int = 5

Huom: Funktion arvon tyyppi ilmaistaan otsikossa, ellei kääntäjä osaa sitä päätellä. Ja palautettavan arvon ilmaisemiseen riittää algoritmin suorituspolun viimeinen ilmaus, mitään returneja ei tarvita. Toisaalta return-lause on myös käytettävissä, jos halutaan algoritmiin useita erillisiä lopetuskohtia. Tätä ei kuitenkaan Scala-maailmassa pidetä tyylikkäänä eikä suotavana!

Huom: Koska "kaikella on arvo" ja arvo on lause-/lausekejonon viimeinen arvo, seuraavanlainen sivuvaikutuksilla pelleilykin on mahdollista:

scala> val x = {println("böö"); 78}
böö
x: Int = 78

Huom: Funktion muodollisten parametrien tyyppi annetaan aina!

"Void-metodin" tyyppi on Unit:

scala> def greet() = println("Hello, world!")
greet: ()Unit

scala> greet
Hello, world!

scala> greet()
Hello, world!

scala> sys exit   // tai toki myös sys.exit tai sys.exit()
$

Huom: Ilman yhtäsuuruusmerkkiä funktion tyyppi on Unit:

scala> def f(a:Int, b:Int) {a-b}
f: (a: Int, b: Int)Unit

scala>  def f(a:Int, b:Int) = {a-b}
f: (a: Int, b: Int)Int

Huom: Kutsussa voi nimetä, mitkä muodolliset parametrit saavat arvokseen todelliset parametrit:

scala> def f(a:Int, b:Int) = {a-b}
f: (a: Int, b: Int)Int

scala> f(1,2)
res3: Int = -1

scala> f(b=1, a=2)
res4: Int = 1

Komentoriviparametri skriptissä

  // Say hello to the first argument
  println("Hello, "+ args(0) +"!")

Valintaa ja toistoa, funktioparametreja

Tuttua ja turvallista:

  var i = 0
  while (i < args.length) {
    println(args(i))
    i += 1
  }

  var i = 0
  while (i < args.length) {
    if (i != 0)
      print(" ")
    print(args(i))
    i += 1
  }
  println()

Skaalautuvalla Scalalla tuommoinen perinneohjelmointi toki onnistuu, ohjelmointi, jossa peräkkäin suoritettavin operaatioin muutetaan ja tutkitaan muuttujien arvoja eli ohjelman tilaa (state).

Mutta Scalalla hommia voi hoidella korkeammallakin abstraktiotasolla. Komentoriviparametrit voi tulostaa vaikka näin:

  args.foreach(arg => println(arg))

• Taulukolle (tässä tuo args) on käytettävissä metodi, joka käy läpi taulukon alkiot.

• Metodi foreach saa parametrina funktion, jota se soveltaa jokaiselle taulukon alkiolle.

• Tässä tuo funktio annetaan funktioliteraalina eli ohjelmatekstiin "kirjaimellisesti" kirjoitettuna nimettömänä funktiona. (Monissa kielissä vaikkapa 3.14 on numeerinen literaali. Kovinkaan monissa "vanhanaikaisissa" kielissä ei ole funktioliteraaleja.)

• Koska nimettömätkin funktiot voivat tarvita parametreja, pitää olla jokin syntaksi ilmaista muodolliset parametrit literaalin tekstissä. Scalan funktioliteraalisyntaksissa muodolliset parametrit kirjoitetaan ennen operaatiota =>. Ja tuon jälkeen funktion runko (eli "metodin algoritmi"). Siis tässä arg => println(arg) on nimetön funktio, joka tulostaa parametrinsa. (Ja "funktioksihan" tuo on aika huono; pelkkiä sivuvaikutuksia eikä mitään kunnon arvoa ...;-)

• Scalan voimakkaan tyyppipäättelyn ansiosta edellä säästettiin kirjoitusvaivoja. Sama voidaan kirjoittaa tarkemmin:

  args.foreach((arg: String) => println(arg))

• Toinen esimerkki funktioliteraalista; nyt matemaatikoidenkin hyväksymänä funktiona:

  (x: Int, y: Int)  => x + y

  Eikö alakin näyttää kahden muuttujan funktiolta, joka kuvaa argumenttinsa argumenttien summalle?

• Itse asiassa komentoriviparametrit voidaan tulostaa vieläkin lyhyemmin:

  args.foreach(println)

  Tässä foreach-metodi saa parametrikseen ns. osittain sovelletun funktion, println-funktion ilman parametria. Metodi foreach osaa sitten itse soveltaa tätä jokaiselle args-taulukon alkiolle. Tästä lisää myöhemmin.

• Saman voi sanoa myös näin nätisti:

  args foreach println

  koska foreach-metodikutsua voi käyttää myös infix-operaattorina.

• Myös seuraava Javan foreach-tapaa muistuttava ratkaisu toimii. Tästäkin lisää myöhemmin.

    for (arg <- args)
      println(arg)
  
  

Esimerkki: Laaditaan funktio, joka saa parametrina kaksi kokonaislukua ja funktion, joka kuvaa kaksi lukua kolmanneksi. Laadittava funktio soveltaa saamaansa funktiota parametrilukuihin:

  def koristele(x: Int, y: Int, arvo: (Int, Int) => Int) =
    println("**** " + arvo(x, y) + " ****")

  koristele(5, 9, (x: Int, y: Int)  => x + y)  // **** 14 ****
  koristele(5, 9, (x: Int, y: Int)  => x * y)  // **** 45 ****

  def erotus(a: Int, b: Int) = a-b
  koristele(5, 9, erotus)                      // **** -4 ****