Scala (Programmiersprache)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Scala
Paradigmen: objektorientiert, funktional, imperativ
Erscheinungsjahr: Seit 2001: interne Arbeiten an der EPFL
2003: Version 1
2006: Version 2
Entwickler: École polytechnique fédérale de Lausanne unter Leitung von Martin Odersky
Aktuelle Version: 2.11  (21. April 2014)
Typisierung: statisch typisiert
Beeinflusst von: Java, Pizza,[1] ML, Haskell, Smalltalk, Erlang
Betriebssystem: plattformunabhängig
Lizenz: Scala,[2] BSD ähnlich
scala-lang.org

Scala ist eine funktionale und objektorientierte Programmiersprache.

Der Name leitet sich von ‘scalable language’ ab und bringt zum Ausdruck, dass der sehr kompakt gehaltene Sprachkern die Möglichkeit bietet, häufig verwendete Sprachelemente wie z. B. Operatoren oder zusätzliche Kontrollstrukturen in Benutzerklassen zu implementieren und dadurch den Sprachumfang zu erweitern und eigene domänenspezifische Sprachen (englisch domain-specific language, DSL) zu erstellen.

Beispiele[Bearbeiten]

Ein Hello, World!-Programm in Scala:

object HelloWorld extends App {
  println("Hello, world!")
}

Eine Implementierung des Quicksort-Algorithmus:

def quickSort[A <% Ordered[A]](xs: List[A]): List[A] = xs match {
  case Nil     => xs
  case y :: ys => ys partition (_ <= y) match {
    case (l1, l2) => quickSort(l1) ++ (y :: quickSort(l2)) }
}

Geschichte[Bearbeiten]

Scala wird im Labor für Programmiermethoden an der École polytechnique fédérale de Lausanne in der Schweiz unter der Leitung von Martin Odersky entwickelt.

Martin Odersky arbeitete unter Niklaus Wirth an Modula 2 und Oberon. Ab 1995 entwickelte er zusammen mit Philip Wadler die Sprache Pizza,[1] die Java um Generics, Funktionszeiger und Pattern Matching erweiterte. Später konzentrierten sich Wadler und Odersky mit Generic Java[3] (GJ) auf Generics für Java, dieses Projekt führte 2004 zur Einführung von Generics in Java.[4] Ab 1999 arbeitete Martin Odersky an der École polytechnique fédérale de Lausanne, wo er an der Verbindung funktionaler und objektorientierter Programmierung forschte und die minimalistische Hybridsprache Funnel[5] entwickelte. Hier begann er 2001 mit der Entwicklung von Scala, die im Gegensatz zu Funnel nicht rein akademischem Interesse dienen sollte, sondern als vollwertige Sprache für reale Anwendungen ausgelegt war. Im Frühjahr 2004 wurde Scala für die Java-Plattform veröffentlicht, im Juni 2004 für .NET.

Seit Anfang 2011 wird die Weiterentwicklung der Sprache vom European Research Council finanziell gefördert. Damit sollen insbesondere die Möglichkeiten der parallelen Programmierung ausgebaut werden.[6]

Am 12. Mai 2011 gab Martin Odersky den Start von Typesafe bekannt; ein Unternehmen, das sich dem kommerziellen Support von Scala im Allgemeinen sowie dem Middleware Framework Akka widmet. Zu den Beratern gehören James Gosling und Doug Lea.[7]

Konzepte[Bearbeiten]

Integration mit Java[Bearbeiten]

Scala-Programme können Java-JARs ansprechen und umgekehrt.[8] Es können also alle bestehenden Java-Bibliotheken und -Frameworks in Scala-Projekte eingebunden und dort genutzt werden. Ähnliches gilt für die meisten Werkzeuge: Entwicklungsumgebungen wie Eclipse, NetBeans oder IntelliJ unterstützen Scala ebenfalls.

Objektorientierung[Bearbeiten]

Scala ist, anders als Java, eine rein objektorientierte Programmiersprache. Jeder Wert ist ein Objekt. Das gilt auch für primitive Datentypen, ohne dass es zu Performance-Einbußen kommt, denn der vom Compiler erzeugte Bytecode verwendet primitive Datentypen.

Interfaces werden über den Mechanismus der Traits implementiert. Traits bestehen nicht nur aus Definitionen, sie können bereits konkrete Implementierungen von Methoden enthalten. Klassen können einen oder mehrere Traits erweitern (Schlüsselwort extends).[9] Dabei handelt es sich nicht um Mehrfachvererbung, sondern um einen Mixin-Mechanismus.

Über das Schlüsselwort object (anstelle von class) wird eine Implementierung des Entwurfsmusters Singleton bereitgestellt.

Funktionale Sprache[Bearbeiten]

Hauptartikel: Funktionale Programmierung

Funktionen sind First-Class-Objekte. Sie können an allen Stellen verwendet werden, an denen Werte erlaubt sind, z. B. Zuweisung an eine Variable (hier ist nicht das Ergebnis der Funktionsauswertung gemeint, sondern die Funktionen selbst) oder bei der Parameterübergabe. Methoden können jederzeit in Funktionen umgewandelt werden, sind selbst aber keine First-Class-Objekte. Auch Funktionen höherer Ordnung[10] sind in Scala realisiert, wodurch beispielsweise Currying ermöglicht wird.

Pattern Matching[Bearbeiten]

Ein wichtiger Aspekt zur Unterstützung der funktionalen Programmierung mit Scala ist Pattern Matching. Im Gegensatz zu der switch Anweisung, wie sie zum Beispiel in Java implementiert ist, arbeitet Pattern Matching nicht nur auf der Basis von Werten, sondern auch bezogen auf die Struktur bzw. den Typ eines Objektes. Unter anderem hierfür wurden Case Classes[11] in Scala implementiert.

Der folgende Code implementiert die Suche in einem binären Suchbaum mithilfe von Pattern Matching und Case Classes:

abstract class Tree
case class Leaf(key: Int) extends Tree
case class Fork(key: Int, left: Tree, right: Tree) extends Tree	
 
def contains(tree: Tree, key: Int): Boolean = tree match {
  case Leaf(i)                      => i == key
  case Fork(i, _, _) if i == key    => true
  case Fork(i, left, _) if key < i  => contains(left, key)
  case Fork(i, _, right) if i < key => contains(right, key)
  // default case
  case _                            => sys.error("should not happen!")
}

Closures[Bearbeiten]

Hauptartikel: Closure

Funktionen greifen nicht nur auf ihre Parameter und lokalen Variablen zu, sondern auch auf Variablen ihres Kontextes (Scope), welche zum Auswertungszeitpunkt gültig sind. Dadurch werden aus open terms die namensgebenden closed terms. Falls sich bei mehrfacher Verwendung der Funktion der Wert einer Variablen des Kontextes gegenüber einem früheren Auswertungszeitpunkt ändert, kann sich auch der Rückgabewert und das Verhalten der Funktion ändern.

Typsystem[Bearbeiten]

Scala ist statisch typisiert. Generische Klassen verwenden Typen, die zum Entwicklungszeitpunkt noch nicht festgelegt sind, z. B. List[T] Oberklassen können abstrakte Typen[12] vorgeben, die von deren Unterklassen in Form konkreter Typen spezifiziert werden müssen. Gleiches gilt für Variablen (var und val) sowie Methoden.

Kovarianz und Kontravarianz[Bearbeiten]

Hauptartikel: Kovarianz und Kontravarianz

Typparameter einer generischen Klasse können mit einer Annotation versehen werden, die bestimmt, wie sich Untertyprelationen von Typargumenten auf die Untertyprelation von generischen Instanziierungen der Klasse auswirken. Invarianz, Syntax: K[T], bedeutet, dass überhaupt kein Zusammenhang besteht. Kovarianz, Syntax: K[+T], bedeutet, dass sich die Relation in gleicher Richtung fortsetzt: Wenn T Untertyp von U ist, dann ist K[T] Untertyp von K[U]. Kontravarianz, Syntax: K[-T], bedeutet, dass die Fortsetzung in der Gegenrichtung erfolgt: Wenn T Untertyp von U ist, dann ist K[U] Untertyp von K[T]. Varianzannotationen beeinflussen, an welcher Stelle innerhalb der generischen Klasse der Typparameter benutzt werden darf: Kovariante Typparameter dürfen beispielsweise nicht als Typ von Methodenargumenten verwendet werden, kontravariante nicht als Rückgabetyp.[13]

Typinferenz[Bearbeiten]

Typinferenz ist die Fähigkeit des Compilers, den Typ eines Ausdrucks aus dem Kontext herzuleiten, welche unter Syntax beispielhaft dargestellt ist.

Auswertungsstrategie[Bearbeiten]

Funktionale Ausdrücke werden in Scala strikt ausgewertet. Allerdings kann durch das Schlüsselwort lazy die verzögerte Auswertung (Lazy-Evaluation) von einzelnen Ausdrücken spezifiziert werden. Auch die Collection-Klassen unterstützen mit den Methoden view und force die Möglichkeit der verzögerten Auswertung. Im Gegensatz hierzu werden in Haskell die Programme standardmäßig lazy ausgewertet und es existieren Strictness-Annotationen.

XML[Bearbeiten]

In den Standardbibliotheken sind grundlegende XML-Operationen und -Datentypen verfügbar: XML-Literale, -Konstruktoren, -Serialisierung und -Deserialisierung, XPath-ähnliche Extraktion von Elementen und Attributen:

   val liste = <einkaufsliste>
                 <artikel><name>Brot</name><preis>3.50</preis></artikel>
                 <artikel><name>Apfel</name><preis>0.29</preis></artikel>
                 <artikel><name>Eier</name><preis>1.19</preis></artikel>
               </einkaufsliste>
   val gesamtpreis = (liste \\ "preis").map(_.text.toDouble).sum
   // Ergebnis: 4.98

Implicits[Bearbeiten]

Methoden können mittels des Modifiers implicit zu sogenannten implicit methods werden. Wenn der Compiler ein Objekt eines bestimmten Typs A erwartet, aber ein Objekt des inkompatiblen Typs B vorfindet, sucht er im lexikalischen Scope und im companion object von A nach einer implicit method, mit der er das B-Objekt in ein A-Objekt konvertieren kann. Mit dieser Technik lassen sich die aus C# bekannten extension methods nachbilden (das sogenannte pimp my library-Pattern) und in Grenzen sogar Vererbung.

Die letzte Parameter-Liste einer Methode kann ebenfalls als implicit markiert werden. Wenn die Parameterliste beim Aufruf einer Methode fehlt, aber ein als implicit markierter Wert im lexikalischen Scope zu finden ist, wird er automatisch an die Methode übergeben. Hiermit ist es möglich, die aus Haskell bekannten type classes als Entwurfsmuster nachzubilden.[14]

Mit impliziten Konversionen wird in Scala auch Verhalten in Bibliotheken implementiert, das viele Sprachen als Spezialfall im Compiler abdecken. So zum Beispiel besondere Regeln beim Zusammenfügen von Zeichenketten wie 42 + "etwas Text" oder die Konvertierung von Zahltypen mit kleinerem Wertebereich zu Zahltypen mit größerem Wertebereich, in Java String concatenation operator +[15] bzw. widening primitive conversions[16] genannt.

Nebenläufigkeit[Bearbeiten]

Hauptartikel: Nebenläufigkeit

Während Scala Threads durch die Java-Klassenbibliothek unterstützt, gibt es in Scalas eigener Bibliothek eine Implementierung von Aktoren. Diese wurde von der Aktoren-Implementierung, wie sie in Erlang umgesetzt wurde, inspiriert. Ab der Scala Version 2.11 wird die ursprüngliche Aktoren-Implementierung nicht mehr Bestandteil der Standard-Bibliothek sein. Ersetzt wird sie durch die Akka-Implementierung (seit der Version 2.10 verfügbar).[17]

Syntax[Bearbeiten]

Die Syntax der Sprache ist an Java und ML angelehnt. Von Java wurde vor allem eine Reihe von Schlüsselworten sowie die Blocksyntax übernommen, von ML die Syntax für Typannotationen und Deklarationen.

Im Vergleich zur Java-Syntax kann in den meisten Fällen das Semikolon am Ende einer Zeile entfallen. Die Syntax zur Typdefinition von Variablen und Rückgabewerten lehnt sich an der von ML statt von Java an: Man formuliert nicht Typ variable, sondern variable: Typ.

Die Deklaration und Definition von Werten, Variablen und Methoden erfolgt mittels der Schlüsselwörter val, var und def, gefolgt von Typangaben.

   val wert: Int = 42
   var variable: Double = 3.14
   def methode(parameter1: String, parameter2: Boolean): Unit

Der Compiler leitet den Typ einer Variable aus dem Kontext ab (Typinferenz). Die beiden Zeilen

   var x = "Ein Text"

und

   var x: String = "Ein Text"

sind somit gleichwertig.

Klassen- und Methodennamen können einen großen Umfang von Zeichen und Symbolen nutzen. Es sind z. B. Bezeichner wie +, *, ::, \\ oder isEmpty_? erlaubt.

Methodenaufrufe mit keinem oder einem Parameter können unter Auslassung des Punktes und der öffnenden und schließenden runden Klammern notiert werden (ähnlich wie in Smalltalk oder Objective-C):

    5.0.+(2.0)
    "Test".startsWith("T")
    List(1,2,3).isEmpty

entspricht

    5.0 + 2.0
    "Test" startsWith "T"
    List(1,2,3) isEmpty

Mit Scala ist es außerdem möglich, den Quelltext im Vergleich zu Java in vielen Fällen kompakter zu schreiben, zum Beispiel auf Grund von Typinferenz, for comprehensions oder anonymen Funktionen.

Operatoren[Bearbeiten]

Für Präfix-Operatoren gibt es eine fest vorgegebene Menge, nämlich +,-,~ und !. Der Ausdruck -x bedeutet das gleiche wie x.unary_-

Postfix-Operator-Ausdrücke sind ebenfalls möglich. Hier gibt es keine Einschränkungen an den Operator, und das Übersetzungsergebnis ist ein Aufruf der (parameterlosen) Methode auf dem Operanden.

Bei Infix-Operatoren entscheidet das erste Zeichen des Operatornamens über Präzedenz und Assoziativität, das den aus der Mathematik üblichen Konventionen folgt. Das Codefragment

    1 + z*x

wird übersetzt zu

    (1).+(z.*(x))

Auf dem Objekt 1 wird die Methode + aufgerufen und dabei der Parameter z.*(x), also das Ergebnis eines weiteren Methodenaufrufes, übergeben.

Endet der Methodenname eines Infixoperators mit einem Doppelpunkt, so vertauscht sich die Reihenfolge von Empfänger und Parameter und der Operator ist rechtsassoziativ:

    a :: b

wird übersetzt zu

    b.::(a)

Schleifen[Bearbeiten]

For-Schleifen wurden zu sogenannten for comprehensions soweit generalisiert, dass sie nicht nur mehrere verschachtelte Schleifen zusammenfassen, sondern analog zu Haskells Do-Notation beliebige Monaden nutzen können.

Dieser Code gibt beispielsweise 27 Zeilen für jeden Wert von a, b und c aus.

for {
  a <- List(1,2,3)
  b <- List(2,3,4)
  c <- List(5,6,7)
} println("a=" + a + ", b=" + b + ", c=" + c)

Eine for comprehension kann auch genutzt werden, um neue Werte zu berechnen, ähnlich wie mit den von Haskell bekannten list comprehensions. Dieser Code weist combinations eine Liste von 4 Paaren zu, nämlich (1,3), (1,4), (2,3) und (2,4):

val combinations = 
  for {
    a <- List(1,2)
    b <- List(3,4)
  } yield (a,b)

Versionen[Bearbeiten]

Scala 2.8[Bearbeiten]

Wesentliche Neuerungen im Release 2.8[18] sind:

  • Überarbeitung der Collection-Library (scala.collection)[19]
  • Überarbeitung der Array-Implementierung[20]
  • benannte Argumente und Defaultwerte für Argumente[21]
  • Delimited Continuations
  • Erweiterungen für Aktoren-Nebenläufigkeit
  • Package-Objekte, die Methoden und Werte für ein Package zur Verfügung stellen

Scala 2.9[Bearbeiten]

Wesentliche Neuerung der Version 2.9 ist die Erweiterung der Collection-Bibliothek um Methoden und Klassen, die Operationen parallel ausführen können (scala.collection.parallel).[22] Daneben gibt es zahlreiche weitere Verbesserungen:

  • Verbesserungen an der interaktiven Konsole (REPL[23] genannt), die nun u. a. schneller startet, mehr Tastenkürzel und bessere Tastaturnavigation beherrscht und Klassen dekompilieren sowie Typen, Ausnahmebedingungen (Exceptions) und verfügbare implizite Konversionen anzeigen kann.
  • Erweiterung von scala.sys um Möglichkeiten, Anweisungen auf der Shell des Betriebssystems auszuführen.
  • Entfernung einiger als veraltet (deprecated) markierter Klassen und Methoden, wie z. B. in scala.Enumeration und deutlichere Markierung bereits veralteter aber noch nicht entfernter Funktionalität, wie z. B. case-Klassen, die von anderen case-Klassen erben oder der Datenbank-Schnittstelle scala.dbc.

Scala 2.10[Bearbeiten]

Wesentliche Neuerungen der Version 2.10.0[24]:

  • neue Implementierung für Pattern Matching
  • Akka-Aktoren als Standardimplementierung
  • Value- und Implicit-Klassen
  • String Interpolation
  • Reflection (experimentell)
  • Makros (experimentell)

Scala 2.11[Bearbeiten]

Die Version 2.11.0 ist gegenüber den Vorgängern stärker modularisiert, wodurch die Kern-Standardbibliothek kleiner wird. Zudem wurden Detailverbesserungen im Bereich der Geschwindigkeit gemacht und die nach wie vor experimentellen Bereiche von Makros und Reflection verbessert. [25]

Bibliotheken und Frameworks[Bearbeiten]

Beliebte Frameworks zur Entwicklung von Web-Applikationen sind Play und Lift. Daneben gibt es viele weitere, meist eher minimalistische Lösungen wie Finatra oder Scalatra. Frameworks aus der Java-Welt, wie Wicket oder Spring können ebenfalls genutzt werden.

Die Interaktion mit Datenbanken wird durch eine Vielzahl von Bibliotheken ermöglicht, darunter Slick, Squeryl und ScalikeJDBC. In Java populäre Ansätze, wie die Nutzung von JPA oder JOOQ, sowie die direkte Verwendung von JDBC, sind ebenfalls möglich.

Zur nebenläufigen Programmierung bietet Scalas Standardbibliothek eine Futures & Promises API[26]. Implementierungen des Aktormodells werden u. a. von Akka[27] und Scalaz[28] bereitgestellt. Darüber hinaus können auch alle Möglichkeiten der Java-Standardbibliothek genutzt werden, z. B. Threads oder java.util.concurrent.*.

Scalaz enthält außerdem viele weitere Konstrukte, welche die funktionale Programmierung in Scala erleichtern.

Scala.js ist ein experimentelles Projekt, das Scala-Code zu JavaScript-Code kompilieren und Scala somit im Browser ausführbar machen kann.

IDE- und Werkzeugunterstützung[Bearbeiten]

Neben dem Compiler scalac steht eine Read-Evaluate-Print-Loop[23] (REPL) namens scala zur Verfügung. Für die IDEs Eclipse,[29] NetBeans[30] und IntelliJ[31] existieren Plugins.

Für den Erstellungsprozess unterstützt Scala u. a. Ant und Maven, stellt aber auch ein eigenes Werkzeug, SBT zur Verfügung.[32]

Verwendung[Bearbeiten]

Scala hat mittlerweile Anwendung in der Industrie gefunden. Die sozialen Netzwerke Twitter und LinkedIn haben ihre Nachrichten-Warteschlangen in Scala implementiert.[33][34]

Weitere Verwendung findet die Sprache etwa in Unternehmen wie Novell[35], Siemens, Sony oder Électricité de France Trading.[36]

Literatur[Bearbeiten]

Weblinks[Bearbeiten]

Einzelnachweise[Bearbeiten]

  1. a b Pizza (programming language) in der englischsprachigen Wikipedia
  2. Lizenz
  3. Generic Java in der englischsprachigen Wikipedia
  4. Generics in Java
  5. Funnel Homepage
  6. EU fördert Open-Source-Sprache Scala. Im heise newsticker, 15. Januar 2011, abgerufen am 23. Februar 2011
  7. typesafe.com
  8. Englischsprachige Vorstellung von Scala auf deren offizieller Internetseite
  9. Traits und Mixin Class Composition (englische Erläuterung auf der Scala-Internetseite)
  10. Funktion höherer Ordnung (englische Erläuterung auf der Scala-Internetseite)
  11. Case Classes (englische Erläuterung auf der Scala-Internetseite)
  12. Abstrakte Typen (englische Erläuterung auf der Scala-Internetseite)
  13. Rückgabetyp (englische Erläuterung auf der Scala-Internetseite)
  14. Type classes (PDF)
  15. Java Sprach-Spezifikation, Version 3, §15.18.1, String Concatenation Operator +
  16. §5.1.2, Widening Primitive Conversion in der Spezifikation der Java-Sprache
  17. The Scala Actors Migration Guide. Abgerufen am 3. Dezember 2013 (englisch).
  18. Release 2.8
  19. Collection-Library
  20. Array-Implementierung
  21. benannte Argumente und Defaultwerte für Argumente
  22. Release 2.9
  23. a b Read–eval–print loop in der englischsprachigen Wikipedia
  24. Changelog
  25. Release 2.11
  26. [1]
  27. akkasource.org
  28. code.google.com
  29. scala-ide.org
  30. wiki.netbeans.org
  31. plugins.intellij.net
  32. code.google.com
  33. artima.com
  34. scala-lang.org
  35. Novell Vibe
  36. scala-lang.org