imported>BrunoBoehmler: /* Literatur */ LIT in Zeilen- statt Tabellenform

2026-04-16T20:21:29Z

Literatur: LIT in Zeilen- statt Tabellenform

Neue Seite

{{Infobox Programmiersprache
| Name = Scala
| Logo = [[Datei:Scala-full-color.svg|220px]]
| Beschreibung = objektorientierte und funktionale Sprache
| Paradigma = [[Objektorientierte Programmierung|objektorientiert]], [[Funktionale Programmierung|funktional]], [[Imperative Programmierung|imperativ]]
| Erscheinungsjahr = 
| Designer = 
| Entwickler = 
| AktuelleVersion = 
| AktuelleVersionFreigabeDatum = 
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Typisierung = [[Statische Typisierung|statisch typisiert]]
| Implementierung =
| Betriebssystem = [[Plattformunabhängigkeit|plattformunabhängig]], [[Java Virtual Machine|JVM]], [[JavaScript]]<ref name="scala-js" />, [[LLVM]]<ref>{{Internetquelle |url=http://www.scala-native.org/ |titel=Scala Native |sprache=en |abruf=2019-04-24}}</ref> (experimentell)
| Dialekte =
| Standardisierungen =
| Beeinflusste = [[Kotlin (Programmiersprache)|Kotlin]]
| Beeinflusst_von = 
| Lizenz = 
| Website = 
}}

'''Scala''' ist eine [[Funktionale Programmiersprache|funktionale]] und [[Objektorientierte Programmiersprache|objektorientierte]] [[Programmiersprache]].

== Konzepte ==
=== Integration mit Java ===
Scala-Programme können [[Java Archive]] (umgangssprachlich JAR-Datei) ansprechen und Java-Programme können Scala-Dateien ansprechen.<ref>[http://www.scala-lang.org/node/25 Englischsprachige Vorstellung von Scala] auf deren offizieller Internetseite.</ref> Es können also alle bestehenden Java-[[Programmbibliothek|Bibliotheken]] und -[[Framework]]s in Scala-Projekte eingebunden und dort genutzt werden. Umgekehrt ist das zwar prinzipiell möglich, in der Praxis aber nicht immer problemlos. Ähnliches gilt für die meisten Werkzeuge: [[Integrierte Entwicklungsumgebung|Entwicklungsumgebungen]] wie [[Eclipse (IDE)|Eclipse]], [[NetBeans]] oder [[IntelliJ]] unterstützen Scala ebenfalls.

=== Objektorientierung ===
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 [[Rechenleistung|Performance]]-Einbußen kommt, denn der vom [[Compiler]] erzeugte Bytecode verwendet primitive Datentypen.

Interfaces werden über den Mechanismus der ''[[Trait (Programmierung)|Traits]]'' implementiert. Traits bestehen nicht nur aus Definitionen, sie können bereits konkrete Implementierungen von Methoden enthalten. [[Klasse (Objektorientierung)|Klassen]] können einen oder mehrere Traits erweitern (Schlüsselwort <code>extends</code>).<ref>[http://www.scala-lang.org/node/126 Traits] und [http://www.scala-lang.org/node/117 Mixin Class Composition] (englische Erläuterung auf der Scala-Internetseite)</ref> Dabei handelt es sich nicht um [[Mehrfachvererbung]], sondern um einen [[Mixin]]-Mechanismus.

Über das Schlüsselwort <code>object</code> (anstelle von <code>class</code>) wird eine Implementierung des [[Entwurfsmuster]]s [[Singleton (Entwurfsmuster)|Singleton]] bereitgestellt. Statische Felder oder Methoden fehlen in Scala, sie werden stattdessen in einem <code>object</code> definiert.

=== Funktionale Sprache ===
{{Hauptartikel|Funktionale Programmierung}}

Funktionen sind [[First-Class-Objekt]]e. Sie können an allen Stellen verwendet werden, an denen Werte erlaubt sind, z. B. Zuweisung an eine [[Variable (Programmierung)|Variable]] (hier ist nicht das Ergebnis der Funktionsauswertung gemeint, sondern die Funktionen selbst) oder bei der Parameterübergabe. Methoden sind selbst aber keine First-Class-Objekte, können aber jederzeit in Funktionen umgewandelt werden. Auch [[Funktion höherer Ordnung|Funktionen höherer Ordnung]]<ref>[http://www.scala-lang.org/node/134 Funktion höherer Ordnung] (englische Erläuterung auf der Scala-Internetseite)</ref> sind in Scala realisiert, wodurch beispielsweise [[Currying]] ermöglicht wird.

==== Pattern Matching ====
Ein wichtiger Aspekt zur Unterstützung der funktionalen Programmierung mit Scala ist [[Pattern Matching]]. Im Gegensatz zu der [[Case-Anweisung#Mehrfache Verzweigung|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. Um auf eine Instanz Pattern Matching anwenden zu können, muss es für sie ein Singleton-Objekt geben, das die unapply-Methode<ref>[https://docs.scala-lang.org/tour/extractor-objects.html#inner-main Extractor Objects] (englische Erläuterung auf der Scala-Internetseite)</ref> implementiert. So kann man Werte aus der Klasse extrahieren, die entsprechend der unapply-Methode von den Feldern der Klasse abgeleitet werden. Da man oft nur die Felder selbst extrahieren muss, gibt es sogenannte Case Classes<ref>[http://www.scala-lang.org/node/107 Case Classes] (englische Erläuterung auf der Scala-Internetseite)</ref> in Scala. Bei ihnen generiert der Scala-Compiler automatisch und vom Programmierer unbemerkt ein gleichnamiges Singleton-Objekt mit apply- und unapply-Methode.

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

<syntaxhighlight lang="scala">
enum Tree:
case Leaf(key: Int)
case Branch(key: Int, left: Tree, right: Tree)

import Tree._

def contains(tree: Tree, key: Int): Boolean = tree match
case Leaf(i) => i == key
case Branch(i, _, _) if i == key => true
case Branch(i, left, _) if i > key => contains(left, key)
case Branch(i, _, right) => contains(right, key)
</syntaxhighlight>

Beispielaufruf:
<syntaxhighlight lang="scala">
val sorted: Tree = Branch(4, Leaf(2), Branch(7, Leaf(6), Leaf(8)))

println(s"contains(sorted, 4) -> ${contains(sorted, 4)}")
println(s"contains(sorted, 5) -> ${contains(sorted, 5)}")
println(s"contains(sorted, 6) -> ${contains(sorted, 6)}")

// Ausgabe:
// contains(sorted, 4) -> true
// contains(sorted, 5) -> false
// contains(sorted, 6) -> true
</syntaxhighlight>

==== Closures ====
{{Hauptartikel|Closure (Funktion)}}

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 ===
Scala ist [[Statische Typisierung|statisch typisiert]].
Generische Klassen verwenden [[Generischer Typ|Typen]], die zum Entwicklungszeitpunkt noch nicht festgelegt sind, z. B. <code>List[T]</code>
Oberklassen können abstrakte Typen<ref>[http://www.scala-lang.org/node/105 Abstrakte Typen] (englische Erläuterung auf der Scala-Internetseite)</ref> vorgeben, die von deren Unterklassen in Form konkreter Typen spezifiziert werden müssen. Gleiches gilt für Variablen (<code>var</code> und <code>val</code>) sowie Methoden.

==== Kovarianz und Kontravarianz ====
{{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: <code>K[T]</code>, bedeutet, dass überhaupt kein Zusammenhang besteht. Kovarianz, Syntax: <code>K[+T]</code>, bedeutet, dass sich die Relation in gleicher Richtung fortsetzt: Wenn <code>T</code> Untertyp von <code>U</code> ist, dann ist <code>K[T]</code> Untertyp von <code>K[U]</code>. Kontravarianz, Syntax: <code>K[-T]</code>, bedeutet, dass die Fortsetzung in der Gegenrichtung erfolgt: Wenn <code>T</code> Untertyp von <code>U</code> ist, dann ist <code>K[U]</code> Untertyp von <code>K[T]</code>. 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.<ref>[http://www.scala-lang.org/node/129 Rückgabetyp] (englische Erläuterung auf der Scala-Internetseite)</ref>

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

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

=== XML ===
Scala 2 unterstützt XML mittels Syntax (XML-Literale) und Standardbibliothek. Mit Version 2.13 wurde die XML-Unterstützung aus der Standardbibliothek entfernt und in das eigenständige Projekt scala-xml ausgelagert.<ref>{{Internetquelle |url=https://github.com/scala/scala/releases/tag/v2.13.0 |titel=Release Scala 2.13.0 · scala/scala |abruf=2021-05-12 |sprache=en}}</ref> Mit Scala 3 wurde auch die Unterstützung für XML-Literale deprecated und wird somit künftig entfernt.<ref>{{Internetquelle |url=http://dotty.epfl.ch/docs/reference/dropped-features/xml.html |titel=Dropped: XML Literals |abruf=2021-05-12}}</ref>

In der scala-xml-Bibliothek sind grundlegende [[XML]]-Operationen und -Datentypen verfügbar: XML-Konstruktoren, -Serialisierung und -Deserialisierung, XPath-ähnliche Extraktion von Elementen und Attributen:
<syntaxhighlight lang="scala">
val liste = <einkaufsliste>
<artikel><name>Brot</name><kosten>3.50</kosten></artikel>
<artikel><name>Apfel</name><kosten>0.29</kosten></artikel>
<artikel><name>Eier</name><kosten>1.19</kosten></artikel>
</einkaufsliste>
val gesamtkosten = (liste \\ "kosten").map(_.text.toDouble).sum
// Ergebnis: 4.98
</syntaxhighlight>

=== Implicits ===
Methoden können mittels des Modifiers <code>implicit</code> 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 ''[[Erweiterungsmethode|extension methods]]'' nachbilden (das sogenannte ''pimp my library''-Pattern) und in Grenzen sogar Vererbung.

Die letzte Parameterliste 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 [[Typklasse (Informatik)|''type classes'']] als Entwurfsmuster nachzubilden<ref>[http://ropas.snu.ac.kr/~bruno/papers/TypeClasses.pdf ''Type classes''] (PDF)</ref>. Scalaz, eine Library zur pur funktionalen Programmierung in Scala, setzt Typklassen weiträumig ein.

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 <code style="white-space:nowrap">42 + "etwas Text"</code> oder die Konvertierung von Zahltypen mit kleinerem Wertebereich zu Zahltypen mit größerem Wertebereich, in Java ''String concatenation operator +''<ref>{{Webarchiv |url=http://docs.oracle.com/javase/specs/jls/se5.0/html/expressions.html#15.18.1 |wayback=20120314071318 |text=Java-Sprach-Spezifikation, Version 3, §15.18.1, String Concatenation Operator +}}</ref> bzw. ''widening primitive conversions''<ref>{{Webarchiv |url=http://docs.oracle.com/javase/specs/jls/se5.0/html/conversions.html#5.1.2 |wayback=20120329144916 |text=§5.1.2, ''Widening Primitive Conversion''}} in der Spezifikation der Java-Sprache</ref> genannt.

=== Nebenläufigkeit ===
{{Hauptartikel|Nebenläufigkeit}}

Während Scala [[Thread (Informatik)|Threads]] durch die Java-Klassenbibliothek unterstützt, gibt es in Scalas eigener Bibliothek eine Implementierung von [[Actor Model|Aktoren]]. Diese wurde von der Aktoren-Implementierung, wie sie in [[Erlang (Programmiersprache)|Erlang]] umgesetzt wurde, inspiriert. Seit der Scala-Version 2.11 ist die ursprüngliche Aktoren-Implementierung nicht mehr Bestandteil der Standardbibliothek. Ersetzt wird sie durch die [[Akka (Software)|Akka]]-Implementierung (ab der Version 2.10 verfügbar)<ref>{{Internetquelle |url=http://docs.scala-lang.org/overviews/core/actors-migration-guide.html |titel=The Scala Actors Migration Guide |sprache=en |offline=ja |archiv-url=https://web.archive.org/web/20131205052405/http://docs.scala-lang.org/overviews/core/actors-migration-guide.html |archiv-datum=2013-12-05 |archiv-bot= |abruf=2013-12-03}}</ref>.

Zusätzlich implementiert die Standard-Library von Scala [[Future (Programmierung)|Futures]] und parallele [[Container (Informatik)|Collections]].

== Syntax ==
Die [[Syntax]] der Sprache ist an [[Java (Programmiersprache)|Java]] und [[ML (Programmiersprache)|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 <code>Typ variable</code>, sondern <code>variable: Typ</code>.

Die Deklaration und Definition von Werten, Variablen und Methoden erfolgt mittels der Schlüsselwörter <code>val</code>, <code>var</code> und <code>def</code>, gefolgt von Typangaben.
<syntaxhighlight lang="scala">
val wert: Int = 42
var variable: Double = 3.14
def methode(parameter1: String, parameter2: Boolean): Unit
</syntaxhighlight>
Der Compiler leitet den Typ einer Variable aus dem Kontext ab ([[Typinferenz]]). Die beiden Zeilen
<syntaxhighlight lang="scala">
var x = "Ein Text"
</syntaxhighlight>
und
<syntaxhighlight lang="scala">
var x: String = "Ein Text"
</syntaxhighlight>
sind somit gleichwertig.

Klassen- und Methodennamen können einen großen Umfang von Zeichen und Symbolen nutzen. Es sind z. B. Bezeichner wie <code>+</code>, <code>*</code>, <code>::</code>, <code>\\</code> oder <code>isEmpty_?</code> 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 (Programmiersprache)|Smalltalk]] oder [[Objective-C]]):
<syntaxhighlight lang="scala">
5.0 + 2.0
"Test" startsWith "T"
List(1,2,3) isEmpty
</syntaxhighlight>
entspricht
<syntaxhighlight lang="scala">
5.0.+(2.0)
"Test".startsWith("T")
List(1, 2, 3).isEmpty
</syntaxhighlight>

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 ===
Für Präfix-Operatoren gibt es eine fest vorgegebene Menge, nämlich <code>+</code>,<code>-</code>,<code>~</code> und <code>!</code>. Der Ausdruck <code>-x</code> bedeutet das gleiche wie <code>x.unary_-</code>

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 [[Operatorrangfolge|Präzedenz]] und [[Operatorassoziativität|Assoziativität]], das den aus der Mathematik üblichen Konventionen folgt. Das Codefragment
<syntaxhighlight lang="scala">
1 + z * x
</syntaxhighlight>
wird übersetzt zu
<syntaxhighlight lang="scala">
(1).+(z.*(x))
</syntaxhighlight>
Auf dem Objekt <code>1</code> wird die Methode <code>+</code> aufgerufen und dabei der Parameter <code>z.*(x)</code>, 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:
<syntaxhighlight lang="scala">
a :: b
</syntaxhighlight>
wird übersetzt zu
<syntaxhighlight lang="scala">
b.::(a)
</syntaxhighlight>

=== Schleifen ===
For-Schleifen wurden zu sogenannten ''for comprehensions'' soweit generalisiert, dass sie nicht nur mehrere verschachtelte Schleifen zusammenfassen, sondern analog zu Haskells Do-Notation beliebige [[Monade (Informatik)|Monaden]] nutzen können.

Dieser Code gibt beispielsweise 27 Zeilen für jeden Wert von a, b und c aus.
<syntaxhighlight lang="scala">
for
a <- List(1, 2, 3)
b <- List(2, 3, 4)
c <- List(5, 6, 7)
do println("a=" + a + ", b=" + b + ", c=" + c)
</syntaxhighlight>

Eine ''for comprehension'' kann auch genutzt werden, um neue Werte zu berechnen, ähnlich wie mit den von Haskell bekannten ''[[List Comprehension]]s''. Dieser Code weist <code>combinations</code> eine Liste von vier Paaren zu, nämlich (1,3), (1,4), (2,3) und (2,4):
<syntaxhighlight lang="scala">
val combinations = for
a <- List(1, 2)
b <- List(3, 4)
yield (a, b)
</syntaxhighlight>

== Versionen ==
=== Scala 2.8 ===
Wesentliche Neuerungen im Release 2.8<ref>{{Cite web|url=https://www.scala-lang.org/old/node/7009|title=Scala 2.8.0 final | The Scala Programming Language|website=www.scala-lang.org}}</ref> sind:
* Überarbeitung der Collection-Library ''(scala.collection)''<ref>{{Cite web|url=https://www.scala-lang.org/old/sid/3|title=New Collection Classes | The Scala Programming Language|website=www.scala-lang.org}}</ref>
* Überarbeitung der Array-Implementierung<ref>{{Cite web|url=https://www.scala-lang.org/old/sid/7|title=Scala 2.8 Arrays | The Scala Programming Language|website=www.scala-lang.org}}</ref>
* benannte Argumente und Defaultwerte für Argumente<ref>{{Cite web|url=https://www.scala-lang.org/old/sid/1|title=Named and Default Arguments | The Scala Programming Language|website=www.scala-lang.org}}</ref>
* 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 ===
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)''.<ref>{{Cite web|url=https://www.scala-lang.org/old/node/9483|title=Scala 2.9.0 final | The Scala Programming Language|website=www.scala-lang.org}}</ref>
Daneben gibt es zahlreiche weitere Verbesserungen:
* Verbesserungen an der interaktiven Konsole (REPL<ref name="REPL">''[[:en:Read–eval–print loop|Read–eval–print loop]]'' in der englischsprachigen Wikipedia</ref> 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 (Betriebssystem)|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. <code>case</code>-Klassen, die von anderen <code>case</code>-Klassen erben oder der [[Datenbank]]-[[Schnittstelle]] ''scala.dbc''.

=== Scala 2.10 ===
Wesentliche Neuerungen der Version 2.10.0<ref>{{Cite web|url=https://www.scala-lang.org/download/changelog.html|title=Changelog|website=www.scala-lang.org}}</ref>:
* neue Implementierung für Pattern Matching
* Akka-Aktoren als Standardimplementierung
* Value- und Implicit-Klassen
* String Interpolation
* Reflection (experimentell)
* Makros (experimentell)

=== Scala 2.11 ===
Die Version 2.11.0 wurde am 17. April 2014 veröffentlicht und 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.<ref>[https://github.com/scala/scala/releases/v2.11.0 Scala 2.11.0 final release!]</ref>

=== Scala 2.12 ===
Die Version 2.12.0 wurde am 3. November 2016 veröffentlicht.<ref>{{Cite web|url=https://www.scala-lang.org/news/2.12.0/|title=Scala 2.12.0 is now available!|website=www.scala-lang.org}}</ref>

=== Scala 3.0 ===
Die Version 3.0.0 wurde am 14. Mai 2021 veröffentlicht. Nennenswerte Änderungen umfassen:<ref>{{Internetquelle |url=https://docs.scala-lang.org/scala3/new-in-scala3.html |titel=New in Scala 3 |abruf=2021-05-21}}</ref>

* ein neues System zur Metaprogrammierung auf Basis von Quotes, Splices und dem Schlüsselwort <code>inline</code>. Dies funktioniert sowohl zur Compilezeit (Macros) wie auch zur Laufzeit
* eine neue einrückungsbasierte Syntax als Alternative zu geschweiften Klammern
* das Schlüsselwort <code>enum</code> zur Deklaration [[algebraischer Datentyp]]en
* Konstruktorparameter für Trait-Typen
* extension methods
* Opake Typaliase
* Das Schlüsselwort <code>implicit</code> wurde als veraltet markiert und durch die Schlüsselwörter <code>given</code>, <code>using</code>, <code>extension</code> und die Typklasse <code>Conversion</code> ersetzt
* Scala-2-Macros werden nicht mehr unterstützt (diese waren in Scala 2 stets als experimentell markiert)

== Bibliotheken und Frameworks ==
Beliebte Frameworks zur Entwicklung von Web-Applikationen sind [[Play Framework|Play]] und [[Lift (Framework)|Lift]]. Daneben gibt es viele weitere, meist eher minimalistische Lösungen wie ''Finatra'' oder ''Scalatra''.
Frameworks aus der Java-Welt, wie [[Apache Wicket|Wicket]] oder [[Spring (Framework)|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 [[Jakarta Persistence API|JPA]] oder [[JOOQ]], sowie die direkte Verwendung von [[JDBC]], sind ebenfalls möglich.

Zur nebenläufigen Programmierung bietet Scalas Standardbibliothek eine ''Futures & Promises'' API.<ref>{{Cite web|url=https://docs.scala-lang.org/overviews/core/futures.html|title=Futures and Promises | Scala Documentation|website=docs.scala-lang.org}}</ref> Implementierungen des [[Actor Model|Aktormodells]] werden u. a. von Akka<ref>[http://akka.io/ akka.io]</ref> und Scalaz<ref>[http://code.google.com/p/scalaz/ code.google.com]</ref> bereitgestellt.
Darüber hinaus können auch alle Möglichkeiten der Java-Standardbibliothek genutzt werden, z. B. [[Thread (Informatik)|Threads]] oder <code>java.util.concurrent.*</code>.

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

Scala.js ist ein Projekt, das Scala-Code zu [[JavaScript]]-Code kompilieren und Scala somit im [[Webbrowser|Browser]] ausführbar machen kann.<ref name="scala-js">{{Internetquelle |url=http://www.scala-js.org/ |titel=Scala.js |sprache=en |abruf=2019-04-24}}</ref>

== IDE- und Werkzeugunterstützung ==
Neben dem Compiler <code>scalac</code> steht eine [[Read-Evaluate-Print-Loop]]<ref name="REPL" /> (REPL) namens <code>scala</code> zur Verfügung. Für die IDEs [[Eclipse (IDE)|Eclipse]]<ref>{{Cite web |url=http://scala-ide.org/ |title=Scala IDE for Eclipse |website=scala-ide.org}}</ref>, [[NetBeans]]<ref>{{Cite web |url=http://wiki.netbeans.org/Scala |title=Scala – NetBeans Wiki |website=wiki.netbeans.org}}</ref> und [[IntelliJ]]<ref>[http://plugins.intellij.net/plugin/?id=1347 plugins.intellij.net]</ref> existieren Plugins.

Für den [[Erstellungsprozess]] unterstützt Scala u. a. [[Apache Ant|Ant]] und [[Apache Maven|Maven]], stellt aber auch ein eigenes Werkzeug, ''SBT'' zur Verfügung.<ref>[https://github.com/sbt/sbt/ github.com/sbt/sbt/]</ref>

== Verwendung ==
Scala hat mittlerweile Anwendung in der Industrie gefunden. Die sozialen Netzwerke [[Twitter#Technik|Twitter]] und [[LinkedIn]] haben ihre Nachrichten-Warteschlangen in Scala implementiert.<ref>{{Cite web|url=https://www.artima.com/scalazine/articles/twitter_on_scala.html|title=Twitter on Scala|website=www.artima.com}}</ref><ref>{{Cite web|url=http://days2010.scala-lang.org/node/138/159/|title=Index of node/138/159|website=days2010.scala-lang.org}}</ref>

Weitere Verwendung findet die Sprache etwa in Unternehmen wie [[Novell]]<ref>[http://vibe.novell.com/ Novell Vibe]</ref>, [[Siemens]], [[Sony]] oder [[Électricité de France|Électricité de France Trading]].<ref>[http://www.scala-lang.org/node/1658 scala-lang.org]</ref>

== Namensherkunft ==
Der Name leitet sich von {{lang|en|„''sca''lable ''la''nguage“}} 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 [[Kontrollstruktur]]en in Benutzerklassen zu implementieren und dadurch den Sprachumfang zu erweitern und eigene [[domänenspezifische Sprache]]n ({{enS|domain-specific language}}, ''DSL'') zu erstellen.

== Beispiele ==
Ein [[Hallo-Welt-Programm|Hello, World!]]-Programm in Scala:
<syntaxhighlight lang="scala">
@main def hello =
println("Hello, world!")
</syntaxhighlight>

Eine generische Implementierung des [[Quicksort]]-Algorithmus mit Context Bounds<ref>[https://docs.scala-lang.org/tutorials/FAQ/context-bounds.html Context Bounds] (englische Erläuterung auf der Scala-Internetseite)</ref>:
<syntaxhighlight lang="scala">
import math.Ordering.Implicits.infixOrderingOps

def quickSort[A : Ordering](xs: List[A]): List[A] = xs match
case Nil => Nil
case y :: ys =>
val (l1, l2) = ys partition (_ <= y)
quickSort(l1) ++ (y :: quickSort(l2))
</syntaxhighlight>

== Geschichte ==
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 (Programmiersprache)|Oberon]]. Von 1995 an entwickelte er zusammen mit [[Philip Wadler]] die inzwischen aufgegebene Programmiersprache ''Pizza''<ref>https://www.artima.com/articles/the-origins-of-scala</ref>, die Java um [[Generics]], [[Funktionszeiger]] und [[Pattern Matching]] erweiterte. Später konzentrierten sich Wadler und Odersky mit ''Generic Java''<ref>''[[:en:Generic Java|Generic Java]]'' in der englischsprachigen Wikipedia</ref> (GJ) auf Generics für Java, dieses Projekt führte 2004 zur Einführung von Generics in Java.<ref>[http://jcp.org/en/jsr/detail?id=14 ''Generics in Java'']</ref> 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''<ref>{{Cite web|url=http://lampwww.epfl.ch/funnel/|title=Functional Nets|website=lampwww.epfl.ch}}</ref> 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 das [[.Net-Framework]].

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.<ref>[https://www.heise.de/newsticker/meldung/EU-foerdert-Open-Source-Sprache-Scala-1170098.html ''EU fördert Open-Source-Sprache Scala''.] Im [[Heise online|heise newsticker]], 15. Januar 2011, abgerufen am 23. Februar 2011</ref>

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 (Software)|Akka]] widmet. Zu den Beratern gehören [[James Gosling]] und Doug Lea.<ref>{{Cite web|url=https://www.lightbend.com/about-lightbend|title=About Lightbend | @lightbend|first=Lightbend|last=Inc|website=Lightbend}}</ref>

== Literatur ==
* {{Literatur |Autor=Martin Odersky, Lex Spoon, Bill Venners |Titel=Programming in Scala |Verlag=Computer Bookshops |Datum=2008 |ISBN=0-9815316-0-1 |Sprache=en}}
* {{Literatur |Autor=Dean Wampler, Alex Payne |Titel=Programming Scala |Verlag=[[O’Reilly Verlag|O’Reilly]] |Datum=2009 |ISBN=978-0-596-15595-7 |Seiten=448 |Online=[http://programming-scala.labs.oreilly.com/ HTML-Version]}}
* {{Literatur |Autor=Lothar Piepmeyer |Titel=Grundkurs funktionale Programmierung mit Scala |Verlag=[[Carl Hanser Verlag|Hanser]] |Datum=2010 |ISBN=978-3-446-42092-2 |Seiten=297}}
* {{Literatur |Autor=Oliver Braun |Titel=Scala: Objektfunktionale Programmierung |Verlag=Hanser |Datum=2010 |ISBN=978-3-446-42399-2 |Seiten=325}}
* {{Literatur |Autor=Friedrich Esser |Titel=Scala für Umsteiger |Verlag=[[Verlag Walter de Gruyter|Oldenbourg Verlag]] |Datum=2011 |ISBN=978-3-486-59693-9 |Seiten=400}}
* {{Literatur |Autor=Heiko Seeberger |Titel=Durchstarten mit Scala |Verlag=entwickler.press |Datum=2011 |ISBN=978-3-86802-064-9 |Seiten=250}}
* {{Literatur |Autor=Thorsten Jolitz |Titel=Objekt-funktionale Programmierung am Beispiel von Scala |Verlag=[[epubli]] |Datum=2013 |ISBN=978-3-8442-4515-8 |Seiten=244}}

== Weblinks ==
* [http://www.scala-lang.org/ Scala Website]
* [http://www.scala-lang.org/docu/files/ScalaReference.pdf The Scala Language Specification] (PDF; 1,3 MB)
* Audiocast-Interviews mit Martin Odersky: [http://www.se-radio.net/2007/07/episode-62-martin-odersky-on-scala/ Umfassende Einführung, Geschichte und Besprechung der Merkmale von Scala (Juli 2007)] [http://www.se-radio.net/2011/02/episode-171-scala-update-with-martin-odersky/ Neuerungen seit 2007, geplante Entwicklungen und Anwendungsbereiche von Scala (Februar 2011)]
* [https://www.sigs-datacom.de/uploads/tx_dmjournals/blankenhorn_seeberger_JS_02_10.pdf JavaSPEKTRUM, 2010, Einführung in Scala Teil 1] (PDF; 194 kB) [https://www.sigs-datacom.de/uploads/tx_dmjournals/blankenhorn_seeberger_JS_03_10.pdf Teil 2] (PDF; 170 kB) [https://www.sigs-datacom.de/uploads/tx_dmjournals/blankenhorn_seeberger_JS_04_10.pdf Teil 3] (PDF; 197 kB)
* [http://scalatutorial.wordpress.com/ Deutsches Scala Tutorial für Umsteiger imperativer Programmiersprachen]
* [https://scastie.scala-lang.org/ Interaktiver Onlineinterpreter zum Ausprobieren]
* [https://days2011.scala-lang.org/sites/days2011/files/ws3-1-Hundt.pdf Google vergleicht C++/Java/Go/Scala] (PDF; 318 kB)

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=7658965-1|LCCN=sh/2010/13203}}

[[Kategorie:Programmiersprache]]
[[Kategorie:Funktionale Programmiersprache]]
[[Kategorie:Objektorientierte Programmiersprache]]
[[Kategorie:Programmiersprache für die Java Virtual Machine]]

Scala (Programmiersprache) - Versionsgeschichte

imported>BrunoBoehmler: /* Literatur */ LIT in Zeilen- statt Tabellenform