Az első lépcsőfokok

    Az emberek folyamatosan keresik a leginkább
megfelelő eszközt a problémák megoldásához. A programozás esetén a
programozási nyelv kiválasztása egy örök vitatéma. Ez a bejegyzés nem
fogja eldönteni ezt a vitát. Mindössze egy ,,új” szereplőt mutat be.
Ez a szereplő a Scala.
Nézzük mit nyújthat ez a nyelv?

• Nyílt forrású, természetesen a hozzá tartozó könyvtár is.
• Több platformon is képes futni. (A leginkább támogatott a JVM-es, de működik .NET-en is.)
• Kompatibilitás (ezáltal rengeteg korábbi megoldást probléma nélkül használhatunk vele). De nem minden áron.
  
• Objektumorientált megközelítés.
• Egyszerűbb XML kezelés.
  
• Funkcionális programozási lehetőség.
• Generikus programozás, könyvtárak. (Bár kissé eltér a szemantikája a Java által követettől.)
• Átgondolt tervek alapján készítették.
• Rugalmas fejlesztési módszer (és néhány a hibára lehetőséget adó konstrukció elhagyása).
• Jelzések (annotation) használata.
• Tömör (például eseti osztályok (case class)).
• Típusinformációk kikövetkeztetése.
• Kötelező kiírni a felüldefiniálást (override) jelző kulcsszót (override).
  
• Nagyszerű közösség. (Régi-új megoldásokkal. Igyekeznek mindenhonnan a legjobbakat ,,összelopkodni”)
  

Ennyit a marketingről… Mi az amitől mégsem annyira kerek ez az egész? (Szubjektív.)

• A
  típust a változó neve után adhatjuk meg. (A Pascalt kedvelőknek
  gondolom épp ez tetszik. Az is igaz, hogy a típusinformációk
  kikövetkeztetése és a lehetőség, hogy a metódus hívások elől a .-ot,
  argumentumai körül a ()-et bizonyos esetekben elhagyhatjuk, így egy
  szeparátor jel mindenképp szükséges, az pedig, hogy így a típus a
  végére kerül végülis nem olyan nagy gond.)
  

• A generikusok jelzésénél nem a <, > párost, hanem a [, ] párost használhatjuk.
  
• A tömbindexelő operátor a ( ), nem pedig a [ ].
• Mozgó
  célpont: a gyakori kiadások nem teljesen kompatibilisek a korábbiakkal.
  (Azért általában 1-2 kiadás idejére még bent marad elavultként
  (deprecated) mielőtt eltávolítanák.)

• Viszonylag kicsi fejlesztői közösség.
• A
  fejlesztő környezet(ek) még nem az igazi(ak). (Legalábbis aki már
  hozzászokott az Eclipse, Netbeans, … tudású eszközökhöz ezt kevésnek
  találhatja.)

• Operátorok
  használatának lehetősége. (Néha jól jön, de az implicit átalakításokkal
  (implicit conversion) együtt kissé kockázatosnak érzem.) Szerencsére
  van precedencia, illetve megadható, hogy jobb-asszociatív legyen.
  

• Nem kötelező ellenőrzött kivételek (checked exception).
• Az, hogy a ; nem kötelező nem igazán tudom megítélni mennyire zavaró. Néha jó, ám néha bosszantó hibák forrása is lehet.
  

    Összességében nem rossz nyelv. Nem egyszerű, de miután ráérez az ember a stílusára kedvelhetővé válik.
Kiknek
szól ez a cikk(sorozat)? Nos, nem a többféle programozási nyelvet jól
ismerőknek. Nekik valószínűleg az Ocaml, LISP, vagy a Haskell után nem
sok újat mutathat. Inkább az objektumorientált fejlesztésben
gyakorlottabbak a célközönség.

Alapok

    A bemutatott példákat az Eclipse-hez készült aktuális (jelenleg beta) kiterjesztés (plugin) segítségével fordítom, futtatom. (A Netbeans rajongók egy-két független kiterjesztés közül válogathatnak: ScalaBeans, Scala Editor (Erlybird)) Ehhez néhány segítség:
A
telepítés a szokásos, a Help/Software Updates/Find and
Install…/Search for new features to install/New Remote Site… részen
az URL: http://lamp.epfl.ch/~mcdirmid/scala.update . Eztán már
telepíthető, csak ki kell választanunk és el kell fogadnunk a licencet.
A használatáról a  A futtatás szintén szokásos.
    Amennyiben nem
eclipse-et használunk a próbálkozásainkhoz, akkor biztosan tetszeni fog
a scala parancs. Ezzel nem csak parancsállományszerűen (script)
futtathatjuk programunkat, de egy interaktív környezetben ki is
próbálhatjuk a képességeit.

Az elmaradhatatlan világunkat üdvözlő program:

object
Hello

{

  def
main(args
: Array[String])
: Unit =
println("Hello
world")

}

Vagy, ha ez jobban tetszik:

object
HelloSimple
extends
Application

{

  println("Hello
world!")

}

    Kezdőknek azt hiszem az utóbbi sokkal
érthetőbb, különösen ha a bőbeszédű Java változatával hasonlítjuk
össze. Kezdjük is ezzel. Az object kulcsszóval egyke (singleton)
osztály egyetlen példányát és magát az osztályt is deklaráljuk. Az
scala.Application egy osztálya a hozzácsomagolt könyvtárnak. (A
scaladoc sajnos nem jön elő F2-re, azonban ha fölé megyünk egérrel
megtudhatjuk, hogy mire is jó.) Ezzel lehet egyerűen futtatható
programot készíteni. Mivel a scala nem tartalmaz statikus (static)
metódusokat (method), emiatt minden ilyesmit az egyke objektumokkal
kell megoldanunk.
    Ekkor nem kell a main metódust elkészítenünk,
de ha nem tesszük (mint ahogy erre nincs is most szükség), akkor a
parancssori paramétereket nem tudjuk felhasználni.
    A kiírást
végző metódus a scala.Predef.println(x: Any), ami a
scala.Console.println(x: Any), ami végül Java platformon a
java.lang.System.out.println(Object x) metódust hívja meg.
    Nézzük
akkor az első példát. Itt ugyanúgy egy egyke objektum létrehozásával
kezdünk, mely alapértelmezésben a scala.ScalaObject
kiterjesztését/implementálását jelenti. Hasonlóan a Java nyelvhez itt
is egy String tömböt paraméterként kapó, visszatérési értékkel nem
rendelkező main metódussal tudjuk jelezni, hogy mit szeretnénk majd
futtatni. Gondolom kiderült, hogy ezek közül mi melyiknek felel meg
(String tömg: Array[String], nincs visszatérési érték, de terminálhat
(szándékunk szerint fog is): Unit). Eztán a metódus implementációját
adjuk meg az = jel után. A println(x: Any) ugyanaz mint korábban, ; itt
sem szükséges utána.

    Nézzünk egy feleslegesen túlbonyolított üdvözlő programot:

object
XmlHello
extends
Application
{

   val
xml = (

    
<!– An xml with
comment –>

    
<hello
who={java.util.Locale.getDefault().getDisplayCountry()}
from="scala"></hello>

    
<tag attribute="value">

      
<hello who="dear
reader" from="author"/>

    
</tag>)

  for
(nodes
<- xml;
//Selecting the nodes of xml
(scala.xml.Elem).

        node
<- nodes
\\ "hello";
//Finding the nodes with label ==
"hello".

        who
<- node
attribute
"who"
//Selecting those which has "who"
attribute.

  )

    println(node.label
+ "
" +
who)
//Printing the label and the who
attribute value.

}

    Amit
nálam kiír az a következő:

hello
Magyarország

hello
dear reader

    Ennek
a példának a részletesebb magyarázata
azonban a következők részekre marad.

    Felmerülhet a kérdés, hogy mire is jó
igazán? Nos erre -egy általános nyelv esetében természetesen- sok
válasz adható. Egyes területekhez kapcsolódó speciális nyelvek
kialakításától matematikai problémák formalizálásán és megoldásán át
webes, adatbázisos alkalmazások készítésén keresztül szinte bármire.
Kinek mihez van kedve?

Folytatás: itt.