Scala (Programmiersprache)

Scala ( / ˈ sk ɑː l ɑː / SKAH -lah ) ^{[ 7 ] [ 8 ]} ist eine stark statisch typisierte, universelle Hochsprache , die sowohl objektorientierte als auch funktionale Programmierung unterstützt . Sie ist auf Prägnanz ausgelegt ^{[ 9 ]} , und viele ihrer Designentscheidungen zielen darauf ab, Kritikpunkte an Java zu begegnen . ^{[ 6 ]}

Scala- Quellcode kann in JVM-Bytecode kompiliert und auf einer Java Virtual Machine (JVM) ausgeführt werden. Alternativ kann Scala in JavaScript transpiliert und im Browser ausgeführt oder mit Clang direkt in eine native ausführbare Datei kompiliert werden . Bei der Ausführung auf der JVM bietet Scala Sprachinteroperabilität mit Java , sodass Bibliotheken beider Sprachen direkt im Scala- oder Java-Code referenziert werden können. ^{[ 10 ]} Wie Java ist auch Scala objektorientiert und verwendet eine Syntax mit geschweiften Klammern , ähnlich der von C. Seit Scala 3 besteht zudem die Möglichkeit, Blöcke mithilfe der Offside-Regel (Einrückung) zu strukturieren , deren Verwendung empfohlen wird. Martin Odersky bezeichnete dies als die produktivste Neuerung in Scala 3. ^{[ 11 ]}

Im Gegensatz zu Java weist Scala viele Merkmale funktionaler Programmiersprachen (wie Scheme , Standard ML und Haskell ) auf, darunter Currying , Unveränderlichkeit , verzögerte Auswertung und Pattern Matching . Es verfügt außerdem über ein fortschrittliches Typsystem, das algebraische Datentypen , Kovarianz und Kontravarianz , Typen höherer Ordnung (jedoch keine Typen höheren Rangs ), anonyme Typen , Operatorüberladung , optionale Parameter , benannte Parameter , Raw Strings und eine experimentelle, ausschließlich auf Ausnahmen basierende Version algebraischer Effekte unterstützt, die als leistungsfähigere Version der geprüften Ausnahmen in Java betrachtet werden kann . ^{[ 12 ]}

Der Name Scala ist ein Kofferwort aus scalable und language und bedeutet, dass es so konzipiert ist, dass es mit den Anforderungen seiner Benutzer mitwachsen kann. ^{[ 13 ]}

Die Entwicklung von Scala begann 2001 an der École Polytechnique Fédérale de Lausanne (EPFL) (in Lausanne , Schweiz ) durch Martin Odersky . Sie knüpfte an die Arbeit an Funnel an, einer Programmiersprache, die Ideen der funktionalen Programmierung und von Petri-Netzen kombiniert . ^{[ 14 ]} Zuvor arbeitete Odersky an Generic Java und javac , dem Java-Compiler von Sun. ^{[ 14 ]}

Nach einer internen Veröffentlichung Ende 2003 wurde Scala Anfang 2004 öffentlich auf der Java-Plattform veröffentlicht . ^{[ 15 ] [ 6 ] [ 14 ] [ 16 ]} Eine zweite Version (v2.0) folgte im März 2006. ^{[ 6 ]}

Am 17. Januar 2011 erhielt das Scala-Team vom Europäischen Forschungsrat (ERC) ein fünfjähriges Forschungsstipendium in Höhe von über 2,3 Millionen Euro . ^{[ 17 ]} Am 12. Mai 2011 gründeten Odersky und seine Mitarbeiter Typesafe Inc. (später umbenannt in Lightbend Inc. ), ein Unternehmen, das kommerziellen Support, Schulungen und Dienstleistungen für Scala anbietet. Typesafe erhielt 2011 eine Investition von 3 Millionen US-Dollar von Greylock Partners . ^{[ 18 ] [ 19 ] [ 20 ] [ 21 ]}

Scala läuft auf der Java-Plattform ( Java Virtual Machine ) und ist mit bestehenden Java -Programmen kompatibel. ^{[ 15 ]} Da Android- Anwendungen typischerweise in Java geschrieben und beim Packen vom JVM-Bytecode in Dalvik -Bytecode übersetzt werden (der bei der Installation gegebenenfalls weiter in nativen Maschinencode übersetzt wird ) , eignet sich Scala aufgrund seiner Java-Kompatibilität hervorragend für die Android-Entwicklung, insbesondere dort, wo funktionale Programmierung bevorzugt wird. ^{[ 22 ]}

Die Referenz-Scala-Softwaredistribution, einschließlich Compiler und Bibliotheken, wird unter der Apache-Lizenz veröffentlicht . ^{[ 23 ]}

Scala.js ist ein Scala-Compiler, der zu JavaScript kompiliert und es ermöglicht, Scala-Programme zu schreiben, die in Webbrowsern oder Node.js ausgeführt werden können . ^{[ 24 ]} Der seit 2013 in Entwicklung befindliche Compiler wurde 2015 (Version 0.6) als nicht mehr experimentell eingestuft. Version 1.0.0-M1 wurde im Juni 2018 und Version 1.1.1 im September 2020 veröffentlicht. ^{[ 25 ]}

Scala Native ist ein Scala- Compiler , der die LLVM -Compiler-Infrastruktur nutzt, um ausführbaren Code mit einer schlanken, verwalteten Laufzeitumgebung zu erzeugen, die den Boehm-Garbage-Collector verwendet . Das Projekt wird von Denys Shabalin geleitet und veröffentlichte seine erste Version 0.1 am 14. März 2017. Die Entwicklung von Scala Native begann 2015 mit dem Ziel, durch den Wegfall der anfänglichen Laufzeitkompilierung des Codes und die Möglichkeit, native Routinen direkt aufzurufen, eine höhere Geschwindigkeit als die Just-in-Time-Kompilierung für die JVM zu erreichen. ^{[ 26 ] [ 27 ]}

Ein Referenz-Scala-Compiler, der auf das .NET Framework und seine Common Language Runtime abzielte , wurde im Juni 2004 veröffentlicht, ^{[ 14 ]} aber 2012 offiziell eingestellt. ^{[ 28 ]}

Das in Scala 3 geschriebene Hello-World-Programm hat folgende Form:

@main def main () = println ( "Hallo Welt!" )

Im Gegensatz zur eigenständigen Hello World-Anwendung für Java gibt es keine Klassendeklaration und nichts wird als statisch deklariert.

Wenn das Programm in der Datei HelloWorld.scala gespeichert ist , kompiliert der Benutzer es mit folgendem Befehl:

$ scalac HelloWorld.scala 

und führt es aus mit

$ scala HelloWorld 

Dies ist analog zum Prozess des Kompilierens und Ausführens von Java-Code. Tatsächlich ist das Kompilierungs- und Ausführungsmodell von Scala identisch mit dem von Java, wodurch es mit Java-Build-Tools wie Apache Ant kompatibel ist .

Eine kürzere Version des Scala-Programms „Hello World“ lautet:

println ( "Hallo Welt!" )

Scala beinhaltet eine interaktive Shell und Skriptunterstützung. ^{[ 29 ]} Gespeichert in einer Datei namens HelloWorld2.scala, kann dies als Skript mit dem Befehl ausgeführt werden:

$ scala HelloWorld2.scala 

Befehle können auch direkt in den Scala-Interpreter eingegeben werden, indem die Option -e verwendet wird :

$ scala -e 'println("Hello, World!")' 

Ausdrücke können interaktiv in der REPL eingegeben werden :

$ scala Willkommen bei Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131). Geben Sie Ausdrücke zur Auswertung ein. Oder versuchen Sie es mit :help.scala> List(1, 2, 3).map(x => x * x) res0: List[Int] = List(1, 4, 9)Scala>

Das folgende Beispiel verdeutlicht die Unterschiede zwischen der Java- und der Scala-Syntax. Die Funktion `mathFunction` nimmt eine ganze Zahl entgegen, quadriert sie und addiert dann die Kubikwurzel dieser Zahl zum natürlichen Logarithmus dieser Zahl. Das Ergebnis wird zurückgegeben (d. h. ): ${\displaystyle n^{2/3}+\ln(n^{2})}$

// Java: int mathFunction ( int num ) { int numSquare = num * num ; return ( int ) ( Math . cbrt ( numSquare ) + Math . log ( numSquare )); }

// Scala: Direkte Konvertierung von Java// Kein Import nötig; scala.math // bereits als `math` importiert def mathFunction ( num : Int ): Int = var numSquare : Int = num * num return ( math . cbrt ( numSquare ) + math . log ( numSquare )). asInstanceOf [ Int ]

// Scala: Idiomatischer // Nutzt Typinferenz, lässt die `return`-Anweisung weg, // verwendet die `toInt`-Methode, deklariert numSquare als unveränderlichimport math . * def mathFunction ( num : Int ) = val numSquare = num * num ( cbrt ( numSquare ) + log ( numSquare )). toInt

Einige syntaktische Unterschiede in diesem Code sind:

• Scala benötigt keine Semikolons (;) am Ende von Anweisungen.
• Werttypen werden großgeschrieben (Satzschreibweise): Int, Double, Booleanstatt int, double, boolean.
• Parameter- und Rückgabetypen folgen, wie in Pascal , anstatt voranzugehen wie in C.
• Methoden müssen mit einem . eingeleitet werden def.
• Lokale oder Klassenvariablen müssen mit einem </code> val(kennzeichnet eine unveränderliche Variable) oder vareinem </code> (kennzeichnet eine veränderliche Variable) eingeleitet werden.
• Der returnOperator ist in einer Funktion unnötig (obwohl er zulässig ist); der Wert der zuletzt ausgeführten Anweisung oder des zuletzt ausgeführten Ausdrucks ist normalerweise der Funktionswert.
• Anstelle des Java-Cast-Operators (Type) fooverwendet Scala foo.asInstanceOf[Type], oder eine spezialisierte Funktion wie toDoubleoder toInt.
• Eine Funktion oder Methode foo()kann auch einfach als aufgerufen werden foo; eine Methode thread.send(signo)kann auch einfach als aufgerufen werden thread send signo; und eine Methode foo.toString()kann auch einfach als aufgerufen werden foo toString.

Diese syntaktischen Lockerungen sollen die Unterstützung domänenspezifischer Sprachen ermöglichen .

Einige weitere grundlegende syntaktische Unterschiede:

• Array-Referenzen werden wie Funktionsaufrufe geschrieben, z. array(i)B. `array.apply(i)` statt `array.apply(i array[i])`. (Intern in Scala wird ersteres zu `array.apply(i)` erweitert, was die Referenz zurückgibt.)
• List[String]Generische Typen werden beispielsweise als `std::type` und nicht als `std::type` in Java geschrieben List<String>.
• Anstelle des Pseudo-Typs voidverfügt Scala über die tatsächliche Singleton-KlasseUnit (siehe unten).

Das folgende Beispiel verdeutlicht den Unterschied zwischen der Definition von Klassen in Java und Scala.

// Java:public class Point {private double x , y ;public Point ( double x , double y ) {this . x = x ;this . y = y ;}public Point ( double x , double y , boolean addToGrid ) {this ( x , y );if ( addToGrid )grid.addPoint ( this ) ;​}public Point () {this ( 0.0 , 0.0 );}private void addPoint ( Point p ) {x += p . x ;y += p . y ;}public double getX () {return x ;}public double getY () {return y ;}double distanceToPoint ( Point other ) {return distanceBetweenPoints ( x , y ,andere . x , andere . y );}private static Point grid = new Point ();static double distanceBetweenPoints (double x1 , double y1 ,double x2 , double y2 ) {return Math.hypot ( x1 - x2 , y1 - y2 ) ;​}}

// ScalaKlasse Punkt (var x : Double , var y : Double ,addToGrid : Boolean = false):import Point . *def += ( p : Punkt ) =x += p . xy += p . yif ( addToGrid )Raster += diesdef this () = this ( 0.0 , 0.0 )def distanceToPoint ( other : Point ) =distanceBetweenPoints ( x , y , other . x , other . y )Endpunkt​Objektpunkt :​private val grid = new Point ()def distanceBetweenPoints ( x1 : Double , y1 : Double ,x2 : Double , y2 : Double ) =Mathe . Hypot ( x1 - x2 , y1 - y2 )

Der obige Code verdeutlicht einige der konzeptionellen Unterschiede zwischen der Klassenbehandlung in Java und Scala:

• Scala kennt keine statischen Variablen oder Methoden. Stattdessen gibt es Singleton-Objekte , die im Wesentlichen Klassen mit nur einer Instanz sind. Singleton-Objekte werden mit `std::` objectanstelle von `std::` deklariert class. Es ist üblich, statische Variablen und Methoden in einem Singleton-Objekt mit demselben Namen wie der Klassennamen zu platzieren; dieses Objekt wird dann als Companion-Objekt bezeichnet . ^{[ 15 ]} (Die zugrundeliegende Klasse des Singleton-Objekts hat ein $angehängtes `std::`. Daher existiert für class Fooein Companion-Objekt object Foointern eine Klasse, Foo$die den Code des Companion-Objekts enthält, und es wird genau ein Objekt dieser Klasse gemäß dem Singleton-Muster erzeugt .)
• Anstelle von Konstruktorparametern verwendet Scala Klassenparameter , die der Klasse zugeordnet werden, ähnlich wie Funktionsparameter. Bei Deklaration mit dem Modifikator `public` valoder var`public` werden Felder ebenfalls mit demselben Namen definiert und automatisch aus den Klassenparametern initialisiert. (Intern erfolgt der externe Zugriff auf öffentliche Felder immer über Getter- und Setter-Methoden, die automatisch erstellt werden. Die Zugriffsfunktion hat denselben Namen wie das Feld, weshalb im obigen Beispiel die explizite Deklaration von Zugriffsmethoden überflüssig ist.) Wie in Java können auch alternative Konstruktoren deklariert werden. Code, der normalerweise im Standardkonstruktor stehen würde (abgesehen von der Initialisierung der Membervariablen), wird direkt auf Klassenebene ausgeführt.
• In Scala ist es möglich, Operatoren zu definieren, indem man Symbole als Methodennamen verwendet. Anstelle von `` addPointdefiniert das Scala-Beispiel `` +=, welches dann mit Infixnotation als `` aufgerufen wird grid += this.
• Die Standard-Sichtbarkeit in Scala ist public.

Scala verwendet dasselbe Kompilierungsmodell wie Java und C# , nämlich separate Kompilierung und dynamisches Laden von Klassen , sodass Scala-Code Java-Bibliotheken aufrufen kann.

Die Funktionsweise von Scala entspricht der von Java. Der Scala-Compiler erzeugt Bytecode, der nahezu identisch mit dem des Java-Compilers ist. ^{[ 15 ]} Tatsächlich lässt sich Scala-Code – mit Ausnahme bestimmter Konstruktoroperationen – in lesbaren Java-Code dekompilieren . Für die Java Virtual Machine (JVM) sind Scala- und Java-Code nicht zu unterscheiden. Der einzige Unterschied besteht in einer zusätzlichen Laufzeitbibliothek scala-library.jar. ^{[ 30 ]}

Scala bietet im Vergleich zu Java zahlreiche zusätzliche Funktionen und weist einige grundlegende Unterschiede in seinem zugrundeliegenden Ausdrucks- und Typenmodell auf. Dies macht die Sprache theoretisch übersichtlicher und beseitigt einige Sonderfälle, die in Java auftreten können. Aus Scala-Sicht ist dies von praktischer Bedeutung, da viele der in Scala hinzugefügten Funktionen auch in C# verfügbar sind.

Wie bereits erwähnt, bietet Scala im Vergleich zu Java eine hohe syntaktische Flexibilität. Im Folgenden einige Beispiele:

• Semikolons sind nicht erforderlich; Zeilen werden automatisch verbunden, wenn sie mit einem Zeichen beginnen oder enden, das normalerweise nicht an dieser Stelle stehen kann, oder wenn nicht geschlossene Klammern vorhanden sind.
• Jede Methode kann als Infix-Operator verwendet werden , z. B. sind `and` "%d apples".format(num)und "%d apples" format num`or` äquivalent. Arithmetische Operatoren wie ` +and` und `or` <<werden tatsächlich wie alle anderen Methoden behandelt, da Funktionsnamen aus beliebigen Symbolfolgen bestehen dürfen (mit wenigen Ausnahmen für Klammern, eckige Klammern und geschweifte Klammern, die speziell behandelt werden müssen). Die einzige Sonderbehandlung solcher symbolbenannter Methoden betrifft die Priorität.
• Methoden applyhaben updatesyntaktische Kurzformen. foo()—wobei fooein Wert (Singleton-Objekt oder Klasseninstanz) ist die Kurzform für foo.apply(), und foo() = 42ist die Kurzform für foo.update(42). Ebenso foo(42)ist die Kurzform für foo.apply(42), und foo(4) = 2ist die Kurzform für foo.update(4, 2). Dies wird für Sammlungsklassen verwendet und lässt sich auf viele andere Fälle, wie z. B. STM- Zellen, erweitern.
• Scala unterscheidet zwischen Methoden ohne Klammern ( def foo = 42) und Methoden mit leeren Klammern ( def foo() = 42). Beim Aufruf einer Methode mit leeren Klammern können die Klammern weggelassen werden. Dies ist nützlich beim Aufruf von Java-Bibliotheken, die diese Unterscheidung nicht kennen, z. B. durch die Verwendung von `std::unique()` anstelle foo.toStringvon ` std::unique()`. foo.toString()Konventionsgemäß sollte eine Methode mit leeren Klammern definiert werden, wenn sie Seiteneffekte erzeugt .
• Methodennamen, die mit einem Doppelpunkt ( :) enden, erwarten das Argument auf der linken und den Empfänger auf der rechten Seite. Beispielsweise 4 :: 2 :: Nilentspricht `` dem Nil.::(2).::(4)`, wobei die erste Form visuell dem Ergebnis entspricht (einer Liste mit dem ersten Element 4 und dem zweiten Element 2).
• Klassenvariablen können transparent als separate Getter- und Setter-Methoden implementiert werden. trait FooLike { var bar: Int }Eine mögliche Implementierung wäre beispielsweise ` get`. Die aufrufende Stelle kann weiterhin eine prägnante Syntax verwenden .objectFooextendsFooLike{privatevarx=0;defbar=x;defbar_=(value:Int){x=value}}}}foo.bar = 42
• Die Verwendung von geschweiften Klammern anstelle von runden Klammern ist in Methodenaufrufen zulässig. Dies ermöglicht reine Bibliotheksimplementierungen neuer Kontrollstrukturen. <sup>[ 31 ]</sup> Beispielsweise breakable { ... if (...) break() ... }sieht es so aus, als breakablewäre `if` ein sprachdefiniertes Schlüsselwort, ist aber in Wirklichkeit nur eine Methode, die ein Thunk -Argument entgegennimmt. Methoden, die Thunks oder Funktionen verwenden, platzieren diese oft in einer zweiten Parameterliste, wodurch die Syntax mit runden Klammern und geschweiften Klammern gemischt werden kann: `if` Vector.fill(4) { math.random }ist dasselbe wie `if` Vector.fill(4)(math.random). Die Variante mit geschweiften Klammern ermöglicht es, den Ausdruck über mehrere Zeilen zu erstrecken.
• For-Ausdrücke (weiter unten erläutert) können jeden Typ aufnehmen, der monadische Methoden wie map, flatMapund definiert filter.

Für sich genommen mögen diese Entscheidungen fragwürdig erscheinen, doch gemeinsam ermöglichen sie die Definition domänenspezifischer Sprachen in Scala, ohne dass der Compiler erweitert werden muss. Beispielsweise kann (und wurde) die spezielle Syntax von Erlang zum Senden einer Nachricht an einen Actor actor ! messagein einer Scala-Bibliothek implementiert, ohne dass Spracherweiterungen erforderlich sind.

Java unterscheidet strikt zwischen primitiven Datentypen (z. B. `int` intund boolean`int`) und Referenztypen (beliebige Klassen ). Nur Referenztypen sind Teil des Vererbungsschemas und erben von `std::` java.lang.Object. In Scala erben alle Datentypen von einer Oberklasse `std::` Any, deren direkte Kinder `std:: AnyVal` (Werttypen wie ` Intint` und ` int` Boolean) und AnyRef`std::` (Referenztypen wie in Java) sind. Das bedeutet, dass die in Java übliche Unterscheidung zwischen primitiven Datentypen und gekapselten Datentypen (z. B. `std ::` intvs. `std Integer::`) in Scala nicht existiert; das Ein- und Auspacken erfolgt für den Benutzer völlig transparent. Scala 2.10 ermöglicht es dem Benutzer, neue Werttypen zu definieren.

Anstelle der Java-„ foreach “-Schleifen zum Durchlaufen eines Iterators verwendet Scala for- forAusdrücke. Diese ähneln List Comprehensions in Sprachen wie Haskell oder einer Kombination aus List Comprehensions und Generatorausdrücken in Python . Mit for-Ausdrücken, die das yieldSchlüsselwort `for` verwenden, kann durch Iteration über eine bestehende Sammlung eine neue Sammlung erzeugt werden, die eine neue Sammlung desselben Typs zurückgibt. Der Compiler übersetzt sie in eine Reihe von map`for`- flatMapund filter`for`-Aufrufen. Wo ` yieldfor` nicht verwendet wird, nähert sich der Code einer imperativen Schleife an, indem er in `for` übersetzt wird foreach.

Ein einfaches Beispiel ist:

val s = for ( x <- 1 to 25 if x * x > 50 ) yield 2 * x

Das Ergebnis der Ausführung ist der folgende Vektor:

Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

(Der Ausdruck 1 to 25ist keine spezielle Syntax. Die Methode toist vielmehr in der Standard-Scala-Bibliothek als Erweiterungsmethode für ganze Zahlen definiert und verwendet eine Technik namens implizite Konvertierungen ^{[ 32 ]} , die es ermöglicht, bestehenden Typen neue Methoden hinzuzufügen.)

Ein komplexeres Beispiel für die Iteration über eine Karte ist:

// Gegeben sei eine Map mit Twitter-Nutzern, die in einer Reihe von Tweets erwähnt werden, // und der Anzahl der Erwähnungen jedes Nutzers. // Suche die Nutzer in einer Map bekannter Politiker und gib eine neue Map zurück, die nur die // demokratischen Politiker (als Objekte, nicht als Strings) enthält. val dem_mentions = for ( mention , times ) <- mentions account <- accounts . get ( mention ) if account . party == "Democratic" yield ( account , times )

Der Ausdruck (mention, times) <- mentionsist ein Beispiel für Pattern Matching (siehe unten). Die Iteration über eine Map liefert eine Menge von Schlüssel-Wert- Paaren . Mithilfe von Pattern Matching lassen sich diese Paare einfach in separate Variablen für Schlüssel und Wert zerlegen. Auch das Ergebnis der Comprehension liefert Schlüssel-Wert-Paare, die automatisch wieder zu einer Map aufgebaut werden, da das Quellobjekt (aus der Variable mentions) eine Map ist. Würde mentionsdie Variable stattdessen eine Liste, ein Set, ein Array oder eine andere Sammlung von Paaren enthalten, würde derselbe Code eine neue Sammlung desselben Typs erzeugen.

Scala unterstützt alle in Java verfügbaren objektorientierten Funktionen (und erweitert diese sogar auf vielfältige Weise) und bietet darüber hinaus zahlreiche Möglichkeiten, die man normalerweise nur in funktionalen Programmiersprachen findet . Diese Funktionen ermöglichen es, Scala-Programme nahezu vollständig funktional zu schreiben und gleichzeitig funktionale und objektorientierte Ansätze zu kombinieren.

Beispiele sind:

• Es wird nicht zwischen Aussagen und Ausdrücken unterschieden.
• Typinferenz
• Anonyme Funktionen mit Erfassungssemantik (d. h. Closures )
• Unveränderliche Variablen und Objekte
• Faule Bewertung
• Begrenzte Fortsetzungen (seit 2.8)
• Funktionen höherer Ordnung
• Verschachtelte Funktionen
• Curry
• Mustererkennung
• Algebraische Datentypen (durch Fallklassen )
• Tupel

Anders als in C oder Java , aber ähnlich wie in Sprachen wie Lisp , unterscheidet Scala nicht zwischen Anweisungen und Ausdrücken . Alle Anweisungen sind Ausdrücke, die zu einem Wert ausgewertet werden. Funktionen, die voidin C oder Java als rückgebend deklariert würden, und ähnliche Anweisungen, whiledie logisch keinen Wert zurückgeben, geben in Scala den Typ `T` zurück Unit, einen Singleton-Typ mit genau einem Objekt dieses Typs. Funktionen und Operatoren, die niemals einen Wert zurückgeben (z. B. der throw`str`-Operator oder eine Funktion, die immer nicht lokal mit einer Ausnahme beendet wird), haben logisch den Rückgabetyp `T` Nothing, einen speziellen Typ ohne Objekte; also einen Basistyp , d. h. eine Unterklasse jedes möglichen Typs. (Dies wiederum macht den Typ `T` Nothingmit jedem Typ kompatibel und ermöglicht die korrekte Typinferenz. ) ^{[ 33 ]}

Analog dazu ist eine if-then-else„Anweisung“ eigentlich ein Ausdruck, der einen Wert erzeugt, d. h. das Ergebnis der Auswertung eines der beiden Zweige. Das bedeutet, dass ein solcher Codeblock überall dort eingefügt werden kann, wo ein Ausdruck benötigt wird, wodurch der ternäre Operator in Scala überflüssig wird.

// Java: char hexDigit = ( char )( x >= 10 ? x + 'A' - 10 : x + '0' );

// Scala: val hexDigit = ( if x >= 10 then x + 'A' - 10 else x + '0' ). toChar

Aus ähnlichen Gründen returnsind `this`-Anweisungen in Scala unnötig und sogar unerwünscht. Wie in Lisp ist der letzte Ausdruck in einem Codeblock der Wert dieses Codeblocks, und wenn der Codeblock der Rumpf einer Funktion ist, wird er von der Funktion zurückgegeben.

Um deutlich zu machen, dass alle Funktionen Ausdrücke sind, Unitwerden selbst Methoden, die einen Wert zurückgeben, mit einem Gleichheitszeichen geschrieben.

def printValue ( x : String ): Unit = println ( "Ich habe ein %s gegessen" . format ( x ))

oder äquivalent (mit Typinferenz und unter Weglassen des unnötigen Zeilenumbruchs):

def printValue ( x : String ) = println ( "Ich habe ein %s gegessen" format x )

Dank der Typinferenz können die Typen von Variablen, Funktionsrückgabewerten und vielen anderen Ausdrücken in der Regel weggelassen werden, da der Compiler sie automatisch ableitet. Beispiele hierfür sind `unveränderliche` val x = "foo"(für eine unveränderliche Konstante oder ein unveränderliches Objekt ) oder var x = 1.5`unveränderliche` (für eine Variable, deren Wert später geändert werden kann). Die Typinferenz in Scala ist im Wesentlichen lokal, im Gegensatz zum globaleren Hindley-Milner -Algorithmus, der in Haskell, ML und anderen rein funktionalen Sprachen verwendet wird. Dies dient der Erleichterung der objektorientierten Programmierung. Daher müssen bestimmte Typen weiterhin deklariert werden (insbesondere Funktionsparameter und die Rückgabetypen rekursiver Funktionen ), z. B. `unveränderliche`.

def formatApples ( x : Int ) = "Ich habe %d Äpfel gegessen" . format ( x )

oder (mit einem für eine rekursive Funktion deklarierten Rückgabetyp)

def factorial ( x : Int ): Int = if x == 0 then 1 else x * factorial ( x - 1 )

In Scala sind Funktionen Objekte, und es gibt eine komfortable Syntax zur Angabe anonymer Funktionen . Ein Beispiel ist der Ausdruck `x = 2` x => x < 2, der eine Funktion mit einem Parameter definiert, die prüft, ob ihr Argument kleiner als 2 ist. Dies entspricht der Lisp-Form `x = 2` . Weder der Typ von `x` noch der Rückgabetyp müssen explizit angegeben werden und können in der Regel durch Typinferenz abgeleitet werden ; sie können aber auch explizit angegeben werden, z. B. als `x = 2` oder sogar als `x = 2` . (lambda(x)(<x2))(x:Int)=>x<2(x:Int)=>(x<2):Boolean

Anonyme Funktionen verhalten sich wie echte Closures, da sie automatisch alle Variablen erfassen, die in der Umgebung der umschließenden Funktion lexikalisch verfügbar sind. Diese Variablen sind auch nach der Rückgabe der umschließenden Funktion verfügbar und müssen, anders als bei anonymen inneren Klassen in Java , nicht als final deklariert werden. (Es ist sogar möglich, solche Variablen zu ändern, sofern sie veränderbar sind; der geänderte Wert steht beim nächsten Aufruf der anonymen Funktion zur Verfügung.)

Eine noch kürzere Form der anonymen Funktion verwendet Platzhaltervariablen : Zum Beispiel die folgende:

list map { x => sqrt(x) }

kann kürzer geschrieben werden als

list map { sqrt(_) }

oder auch

list map sqrt

Scala unterscheidet zwischen veränderlichen und unveränderlichen Variablen. Veränderliche Variablen werden mit dem varSchlüsselwort `val` deklariert, unveränderliche mit dem valSchlüsselwort `val`. Eine mit ` valval` deklarierte Variable kann nicht neu zugewiesen werden, analog zur finalNeuzuweisung einer mit `val` deklarierten Variable in Java. valVariablen sind nur oberflächlich unveränderlich, d. h., ein Objekt, auf das `val` verweist, ist nicht zwangsläufig selbst unveränderlich.

Unveränderliche Klassen werden jedoch konventionsgemäß empfohlen, und die Scala-Standardbibliothek bietet eine Vielzahl unveränderlicher Collection- Klassen. Scala stellt veränderliche und unveränderliche Varianten der meisten Collection-Klassen bereit, wobei immer die unveränderliche Version verwendet wird, sofern die veränderliche nicht explizit importiert wird. ^{[ 34 ]} Die unveränderlichen Varianten sind persistente Datenstrukturen , die stets eine aktualisierte Kopie eines alten Objekts zurückgeben, anstatt das alte Objekt destruktiv zu verändern. Ein Beispiel hierfür sind unveränderliche verkettete Listen. Das Einfügen eines Elements am Anfang einer Liste erfolgt durch die Rückgabe eines neuen Listenknotens, der aus dem Element und einer Referenz auf das Ende der Liste besteht. Das Anhängen eines Elements an eine Liste ist nur möglich, indem alle Elemente der alten Liste einer neuen Liste mit nur dem neuen Element vorangestellt werden. Ebenso kopiert das Einfügen eines Elements in die Mitte einer Liste die erste Hälfte der Liste, behält aber eine Referenz auf die zweite Hälfte. Dies wird als strukturelles Sharing bezeichnet. Dadurch wird sehr einfache Parallelverarbeitung ermöglicht – es werden keine Sperren benötigt, da keine gemeinsam genutzten Objekte verändert werden. ^{[ 35 ]}

Die Auswertung erfolgt standardmäßig strikt („eager“). Das heißt, Scala wertet Ausdrücke aus, sobald sie verfügbar sind, und nicht erst bei Bedarf. Variablen können jedoch mit dem lazySchlüsselwort `lazy` als nicht-strikt („lazy“) deklariert werden. In diesem Fall wird der Code zur Erzeugung des Variablenwerts erst beim ersten Zugriff auf die Variable ausgewertet. Es gibt auch nicht-strikte Sammlungen verschiedener Typen (z. B. `List` Stream, eine nicht-strikte verkettete Liste), und jede Sammlung kann mit der Methode `unstrict` in eine nicht-strikte Sammlung umgewandelt werden view. Nicht-strikte Sammlungen eignen sich semantisch gut für serverseitig erzeugte Daten, da die Auswertung des Codes zur Generierung der nachfolgenden Listenelemente (die wiederum eine Anfrage an einen Server auslöst, der sich möglicherweise an einer anderen Stelle im Web befindet) erst erfolgt, wenn die Elemente tatsächlich benötigt werden.

Funktionale Programmiersprachen bieten üblicherweise Endrekursionsoptimierung , um die umfangreiche Nutzung von Rekursion ohne Stack-Overflow -Probleme zu ermöglichen . Einschränkungen im JVM-Bytecode erschweren die Endrekursionsoptimierung auf der JVM. Im Allgemeinen lässt sich eine Funktion optimieren, die sich selbst per Endrekursion aufruft, nicht jedoch sich gegenseitig rekursive Funktionen. Trampoline wurden als Workaround vorgeschlagen. ^{[ 36 ]} Die Scala-Bibliothek bietet scala.util.control.TailCallsseit Scala 2.8.0 (veröffentlicht am 14. Juli 2010) Trampoline-Unterstützung. Eine Funktion kann optional mit `@Trampoline` annotiert werden @tailrec; in diesem Fall lässt sie sich nur kompilieren, wenn sie endrekursiv ist. ^{[ 37 ]}

Ein Beispiel für diese Optimierung lässt sich anhand der Fakultätsdefinition umsetzen . Zum Beispiel die rekursive Version der Fakultät:

def factorial ( n : Int ): Int = if n == 0 then 1 else n * factorial ( n - 1 )

Könnte zur endrekursiven Version wie folgt optimiert werden:

@tailrec def faktoriell ( n : Int , akkumuliert : Int ): Int = wenn n == 0 , dann akkumuliert , sonst faktoriell ( n - 1 , n * akkumuliert )

Dies könnte jedoch die Komposition mit anderen Funktionen aufgrund des neuen Arguments in ihrer Definition beeinträchtigen, weshalb es üblich ist, Closures zu verwenden , um ihre ursprüngliche Signatur zu erhalten:

def factorial ( n : Int ): Int =@tailrecdef Schleife ( aktuell : Int , akkumuliert : Int ): Int =Wenn Strom == 0 , dann Akkumulationelse- Schleife ( Strom - 1 , Strom * Akku )loop ( n , 1 ) // Aufruf der Closure mit dem BasisfallEndfaktor​

Dies gewährleistet die Endrekursionsoptimierung und verhindert somit einen Stack-Overflow-Fehler.

Scala bietet integrierte Unterstützung für Pattern Matching , das als eine erweiterte und komplexere Version einer Switch-Anweisung betrachtet werden kann . Hierbei lassen sich beliebige Datentypen vergleichen (nicht nur einfache Typen wie Integer, Booleans und Strings), einschließlich beliebiger Verschachtelung. Es gibt eine spezielle Klasse, die sogenannte Case-Klasse . Diese unterstützt Pattern Matching automatisch und kann zur Modellierung der in vielen funktionalen Programmiersprachen verwendeten algebraischen Datentypen eingesetzt werden . (In Scala ist eine Case-Klasse im Grunde eine normale Klasse, der der Compiler automatisch bestimmte Verhaltensweisen hinzufügt, die auch manuell definiert werden könnten, z. B. Methoden für tiefe Vergleiche und Hashing sowie die Destrukturierung der Konstruktorparameter während des Pattern Matchings.)

Ein Beispiel für eine Definition des Quicksort -Algorithmus mittels Mustererkennung ist folgendes:

def qsort ( list : List [ Int ]): List [ Int ] = list match case Nil = > Nil case pivot :: tail = > val ( smaller , rest ) = tail.partition ( _ < pivot ) qsort ( smaller ) ::: pivot :: qsort ( rest )

Die Idee besteht darin, eine Liste in Elemente kleiner als ein Pivot-Element und Elemente größer als ein Pivot-Element zu unterteilen, jeden Teil rekursiv zu sortieren und die Ergebnisse anschließend mit dem Pivot-Element dazwischen zusammenzufügen. Dies entspricht der Divide-and-Conquer- Strategie von Mergesort und anderen schnellen Sortieralgorithmen.

Der matchOperator dient dem Mustervergleich des in gespeicherten Objekts list. Jeder caseAusdruck wird nacheinander geprüft, ob er übereinstimmt, und die erste Übereinstimmung bestimmt das Ergebnis. In diesem Fall Nilfindet nur das Literalobjekt Nil, während pivot :: taileine nicht leere Liste gefunden und gleichzeitig gemäß dem angegebenen Muster dekonstruiert wird . Der zugehörige Code hat dann Zugriff auf eine lokale Variable namens , pivotdie den Anfang der Liste speichert, und eine weitere Variable, taildie das Ende der Liste speichert. Diese Variablen sind schreibgeschützt und semantisch sehr ähnlich zu Variablenbindungen, die mit dem letOperator in Lisp und Scheme hergestellt werden.

Pattern Matching findet auch bei lokalen Variablendeklarationen statt. In diesem Fall tail.partitionist der Rückgabewert des Aufrufs ein Tupel – in diesem Fall zwei Listen. (Tupel unterscheiden sich von anderen Containertypen, z. B. Listen, dadurch, dass sie immer eine feste Größe haben und die Elemente unterschiedliche Typen haben können – obwohl sie hier beide vom selben Typ sind.) Pattern Matching ist die einfachste Methode, die beiden Teile des Tupels zu extrahieren.

Das Formular _ < pivotist eine Deklaration einer anonymen Funktion mit einer Platzhaltervariablen; siehe den obigen Abschnitt über anonyme Funktionen.

Die Listenoperatoren ::(der ein Element am Anfang einer Liste hinzufügt, ähnlich wie consin Lisp und Scheme) und :::(der zwei Listen aneinanderhängt, ähnlich wie appendin Lisp und Scheme) kommen beide vor. Trotz des ersten Eindrucks sind diese Operatoren nicht fest in die Liste integriert. Wie bereits erwähnt, kann jede beliebige Zeichenkette als Funktionsname dienen, und eine Methode, die auf ein Objekt angewendet wird, kann in Infix-Schreibweise ohne Punkt und Klammern geschrieben werden. Die obige Zeile lautet wie folgt:

qsort(smaller) ::: pivot :: qsort(rest)

könnte auch folgendermaßen geschrieben werden:

qsort(rest).::(pivot).:::(qsort(smaller))

in der üblicheren Methodenaufrufnotation. (Methoden, die mit einem Doppelpunkt enden, sind rechtsassoziativ und binden an das Objekt rechts davon.)

Im obigen Beispiel zur Mustererkennung matchist der Rumpf des Operators eine partielle Funktion , die aus einer Reihe von caseAusdrücken besteht, wobei der erste übereinstimmende Ausdruck Vorrang hat, ähnlich dem Rumpf einer Switch-Anweisung . Partielle Funktionen werden auch im Ausnahmebehandlungsteil einer tryAnweisung verwendet:

try ... catch case nfe : NumberFormatException => { println ( nfe ); List ( 0 ) } case _ => Nil

Schließlich kann eine partielle Funktion auch allein verwendet werden, und das Ergebnis ihres Aufrufs entspricht der Anwendung eines Operators matchdarauf. Beispielsweise kann der vorherige Code für Quicksort folgendermaßen geschrieben werden:

val qsort : List [ Int ] => List [ Int ] = case Nil => Nil case pivot :: tail => val ( smaller , rest ) = tail . partition ( _ < pivot ) qsort ( smaller ) ::: pivot :: qsort ( rest )

Hier wird eine schreibgeschützte Variable deklariert, deren Typ eine Funktion von Listen ganzer Zahlen in Listen ganzer Zahlen ist, und sie wird an eine partielle Funktion gebunden. (Der einzige Parameter der partiellen Funktion wird nie explizit deklariert oder benannt.) Wir können diese Variable jedoch weiterhin genau so aufrufen, als wäre sie eine normale Funktion:

scala > qsort ( List ( 6 , 2 , 5 , 9 )) res32 : List [ Int ] = List ( 2 , 5 , 6 , 9 )

Scala ist eine rein objektorientierte Sprache, da jeder Wert ein Objekt ist . Datentypen und das Verhalten von Objekten werden durch Klassen und Traits beschrieben . Klassenabstraktionen werden durch Subklassen und einen flexiblen, auf Mixins basierenden Kompositionsmechanismus erweitert, um Probleme der Mehrfachvererbung zu vermeiden .

Traits sind in Scala der Ersatz für Java- Interfaces . Interfaces in Java-Versionen vor 8 sind stark eingeschränkt und können nur abstrakte Funktionsdeklarationen enthalten. Dies hat zu Kritik geführt, da die Bereitstellung von Hilfsmethoden in Interfaces umständlich ist (die gleichen Methoden müssen in jeder Implementierung neu implementiert werden) und die abwärtskompatible Erweiterung eines veröffentlichten Interfaces unmöglich ist. Traits ähneln Mixin- Klassen, da sie fast die gesamte Funktionalität einer regulären abstrakten Klasse besitzen, nur die Klassenparameter (Scalas Äquivalent zu Javas Konstruktorparametern) fehlen, da Traits immer mit einer Klasse kombiniert werden. Der superOperator verhält sich in Traits speziell und ermöglicht die Verkettung von Traits mittels Komposition zusätzlich zur Vererbung. Das folgende Beispiel ist ein einfaches Fenstersystem:

abstract class Window : // abstract def draw ()class SimpleWindow extends Window : def draw () println ( "in SimpleWindow" ) // zeichnet ein einfaches FensterDas Merkmal WindowDecoration erweitert Windowtrait HorizontalScrollbarDecoration extends WindowDecoration : // "abstract override" ist hier nötig, damit "super()" funktioniert, da die übergeordnete Funktion abstrakt ist. Wäre sie konkret, würde ein normales "override" genügen. abstract override def draw () println ( "in HorizontalScrollbarDecoration" ) super . draw () // Jetzt eine horizontale Scrollleiste zeichnentrait VerticalScrollbarDecoration extends WindowDecoration : abstract override def draw () println ( "in VerticalScrollbarDecoration" ) super . draw () // jetzt eine vertikale Scrollleiste zeichnentrait TitleDecoration extends WindowDecoration : abstract override def draw () println ( "in TitleDecoration" ) super . draw () // jetzt die Titelleiste zeichnen

Eine Variable kann folgendermaßen deklariert werden:

val mywin = new SimpleWindow with VerticalScrollbarDecoration with HorizontalScrollbarDecoration with TitleDecoration

Das Ergebnis des Aufrufs mywin.draw()ist:

in TitleDecoration in HorizontalScrollbarDecoration in VerticalScrollbarDecoration in SimpleWindow

Anders ausgedrückt: Der Aufruf drawführte zunächst den Code in TitleDecoration(dem zuletzt hinzugefügten Trait) aus und super()durchlief dann (über die Aufrufe) die anderen hinzugefügten Traits und schließlich den Code in Window, obwohl keines der Traits voneinander erbte . Dies ähnelt dem Dekorator-Muster , ist aber prägnanter und weniger fehleranfällig, da es weder die explizite Kapselung des übergeordneten Fensters noch das explizite Weiterleiten von Funktionen erfordert, deren Implementierung unverändert bleibt, noch die Initialisierung von Entitätsbeziehungen zur Laufzeit. In anderen Sprachen ließe sich ein ähnlicher Effekt zur Kompilierzeit mit einer langen linearen Kette von Implementierungsvererbung erzielen , jedoch mit dem Nachteil gegenüber Scala, dass für jede mögliche Kombination der Mix-ins eine lineare Vererbungskette deklariert werden müsste.

Scala verfügt über ein ausdrucksstarkes statisches Typsystem, das weitgehend die sichere und kohärente Verwendung von Abstraktionen gewährleistet. Das Typsystem ist jedoch nicht korrekt . ^{[ 38 ]} Insbesondere unterstützt das Typsystem Folgendes:

• Klassen und abstrakte Typen als Objektmitglieder
• Strukturtypen
• Pfadabhängige Typen
• Verbindungstypen
• Explizit getippte Selbstbezüge
• Generische Klassen
• Polymorphe Methoden
• Obere und untere Typgrenzen
• Varianz
• Anmerkung
• Ansichten

Scala kann Typen anhand ihrer Verwendung ableiten. Dadurch sind die meisten statischen Typdeklarationen optional. Statische Typen müssen nicht explizit deklariert werden, es sei denn, ein Compilerfehler weist darauf hin. In der Praxis werden manche statische Typdeklarationen jedoch aus Gründen der Codeübersichtlichkeit eingefügt.

Eine gängige Technik in Scala, bekannt als „Enrich My Library“ ^{[ 39 ]} (ursprünglich 2006 von Martin Odersky als „ Pimp My Library “ bezeichnet ^{[ 32 ]} – diese Formulierung stieß aufgrund ihrer negativen Konnotationen ^{[ 40 ]} und ihrer Unausgereiftheit ^{[ 41 ]} auf Kritik ), ermöglicht die Verwendung neuer Methoden, als wären sie bestehenden Typen hinzugefügt worden. Dies ähnelt dem Konzept der Erweiterungsmethoden in C# , ist aber leistungsfähiger, da die Technik nicht auf das Hinzufügen von Methoden beschränkt ist, sondern beispielsweise auch zur Implementierung neuer Schnittstellen verwendet werden kann. In Scala beinhaltet diese Technik die Deklaration einer impliziten Konvertierung vom Typ, der die Methode „empfängt“, zu einem neuen Typ (typischerweise einer Klasse), der den ursprünglichen Typ umschließt und die zusätzliche Methode bereitstellt. Falls für einen gegebenen Typ keine Methode gefunden wird, sucht der Compiler automatisch nach anwendbaren impliziten Konvertierungen zu Typen, die die betreffende Methode bereitstellen.

Diese Technik ermöglicht es, einer bestehenden Klasse mithilfe einer Zusatzbibliothek neue Methoden hinzuzufügen, sodass nur der Code, der die Zusatzbibliothek importiert , die neue Funktionalität erhält, während der gesamte übrige Code unberührt bleibt.

Das folgende Beispiel zeigt die Anreicherung des Typs Intmit Methoden isEvenund isOdd:

Objekt MyExtensions : Erweiterung ( i : Int ) def isEven = i % 2 == 0 def isOdd = ! ich . ist geradeimport MyExtensions . * // Implizite Anreicherung in den Gültigkeitsbereich bringen 4 . isEven // -> true

Durch das Importieren der Mitglieder MyExtensionswird die implizite Konvertierung zur Erweiterungsklasse IntPredicatesin den Gültigkeitsbereich gebracht. ^{[ 42 ]}

Die Scala-Standardbibliothek unterstützt neben den Standard-Java-Concurrency-APIs auch Futures und Promises . Ursprünglich enthielt sie auch Unterstützung für das Actor-Modell , das nun als separate , quelloffene Plattform Akka ^{[ 43 ]} von Lightbend Inc. lizenziert ist . Akka-Actors können verteilt oder mit Software Transactional Memory ( Transactor ) kombiniert werden. Alternative Implementierungen von Communicating Sequential Processes (CSP) für kanalbasierte Nachrichtenübermittlung sind Communicating Scala Objects ^{[ 44 ]} oder JCSP .

Ein Actor ist vergleichbar mit einer Thread-Instanz mit einer Mailbox. Er kann erstellt werden system.actorOf, indem die receiveMethode zum Empfangen von Nachrichten überschrieben und die !Methode zum Senden einer Nachricht (mit Ausrufezeichen) verwendet wird. ^{[ 45 ]} Das folgende Beispiel zeigt einen EchoServer, der Nachrichten empfangen und anschließend ausgeben kann.

val echoServer = actor ( new Act : become : case msg => println ( "echo " + msg ) )echoServer ! "hi"

Scala bietet außerdem eine integrierte Unterstützung für datenparallele Programmierung in Form von Parallel Collections ^{[ 46 ],} die seit Version 2.9.0 in die Standardbibliothek integriert sind.

Das folgende Beispiel zeigt, wie man Parallel Collections zur Leistungsverbesserung einsetzen kann. ^{[ 47 ]}

val urls = List ( "https://scala-lang.org" , "https://github.com/scala/scala" )def fromURL ( url : String ) = scala.io.Source.fromURL ( url ) .getLines ( ) . mkString ( " \ n " )​​val t = System.currentTimeMillis ( ) urls.par.map ( fromURL ( _ ) ) // par gibt eine parallele Implementierung einer Sammlung zurück println ( "Zeit: " + ( System.currentTimeMillis - t ) + " ms " )

Neben Futures und Promises, Actor-Unterstützung und Datenparallelität unterstützt Scala auch asynchrone Programmierung mit Software Transactional Memory und Event Streams. ^{[ 48 ]}

Die bekannteste Open-Source-Lösung für Cluster-Computing, die in Scala geschrieben ist, ist Apache Spark . Auch Apache Kafka , die bei Spark und anderen Stream-Processing-Technologien beliebte Publish-Subscribe- Nachrichtenwarteschlange , ist in Scala geschrieben.

Es gibt verschiedene Möglichkeiten, Code in Scala zu testen. ScalaTest unterstützt mehrere Testarten und lässt sich in Java-basierte Testframeworks integrieren. ^{[ 49 ]} ScalaCheck ist eine Bibliothek ähnlich wie QuickCheck in Haskell . ^{[ 50 ]} specs2 ist eine Bibliothek zum Schreiben ausführbarer Softwarespezifikationen. ^{[ 51 ]} ScalaMock bietet Unterstützung für das Testen von Funktionen höherer Ordnung und curried Funktionen. ^{[ 52 ]} JUnit und TestNG sind beliebte, in Java geschriebene Testframeworks.

Scala wird häufig mit Groovy und Clojure verglichen , zwei weiteren Programmiersprachen, die ebenfalls die JVM nutzen. Wesentliche Unterschiede zwischen diesen Sprachen bestehen im Typsystem, im Umfang der Unterstützung objektorientierter und funktionaler Programmierung sowie in der Ähnlichkeit ihrer Syntax zu der von Java.

Scala ist statisch typisiert , während Groovy und Clojure dynamisch typisiert sind . Dies macht das Typsystem komplexer und schwerer verständlich, ermöglicht aber, fast alle Typfehler ^{[ 38 ]} zur Kompilierzeit zu erkennen und kann zu einer deutlich schnelleren Ausführung führen. Im Gegensatz dazu erfordert die dynamische Typisierung mehr Tests, um die Korrektheit des Programms sicherzustellen, und ist daher im Allgemeinen langsamer, um eine größere Programmierflexibilität und -einfachheit zu ermöglichen. Aktuelle Versionen von Groovy und Clojure erlauben optionale Typannotationen, um den Overhead der dynamischen Typisierung in Fällen zu vermeiden, in denen Typen praktisch statisch sind. Dieser Overhead wird durch die Verwendung aktueller JVM-Versionen weiter reduziert, da diese um die Anweisung `invoke dynamic` für Methoden mit dynamisch typisierten Argumenten erweitert wurden. Diese Fortschritte verringern den Geschwindigkeitsunterschied zwischen statischer und dynamischer Typisierung, obwohl eine statisch typisierte Sprache wie Scala weiterhin die bevorzugte Wahl ist, wenn die Ausführungseffizienz von großer Bedeutung ist.

Was die Programmierparadigmen betrifft, so erbt Scala das objektorientierte Modell von Java und erweitert es auf vielfältige Weise. Groovy ist zwar ebenfalls stark objektorientiert, legt aber mehr Wert auf die Reduzierung der Ausführlichkeit des Codes. In Clojure wird die objektorientierte Programmierung weniger stark betont, die funktionale Programmierung ist die Hauptstärke der Sprache. Scala bietet ebenfalls viele Möglichkeiten zur funktionalen Programmierung, darunter auch Funktionen, die man in fortgeschrittenen funktionalen Sprachen wie Haskell findet, und versucht, zwischen den beiden Paradigmen neutral zu sein, sodass Entwickler zwischen ihnen oder, häufiger, einer Kombination wählen können.

Was die Syntaxähnlichkeit mit Java betrifft, so erbt Scala, wie auch Groovy, einen Großteil der Java-Syntax. Clojure hingegen folgt der Lisp- Syntax, die sich sowohl im Erscheinungsbild als auch in der Philosophie unterscheidet.

Bereits 2013, als Scala in Version 2.10 vorlag, empfahl der ThoughtWorks Technology Radar, ein halbjährlich erscheinender, meinungsbasierter Bericht einer Gruppe hochrangiger Technologieexperten, ^{[ 156 ]} die Einführung von Scala in seiner Kategorie „Sprachen und Frameworks“. ^{[ 157 ]}

Im Juli 2014 wurde diese Einschätzung präzisiert und bezieht sich nun auf „Scala, die guten Seiten“, die wie folgt beschrieben werden: „Um Scala erfolgreich einzusetzen, müssen Sie die Sprache erforschen und eine klare Meinung darüber haben, welche Teile für Sie die richtigen sind, und Ihre eigene Definition von Scala, den guten Seiten, erstellen.“ ^{[ 158 ]}

In der 2018er Ausgabe der „State of Java“ -Umfrage ^{[ 159 ]} , für die Daten von 5160 Entwicklern zu verschiedenen Java-bezogenen Themen erhoben wurden, belegte Scala den dritten Platz hinsichtlich der Nutzung alternativer Sprachen auf der JVM . Im Vergleich zur Vorjahresausgabe der Umfrage sank die Nutzung von Scala unter den alternativen JVM-Sprachen von 28,4 % auf 21,5 % und wurde von Kotlin überholt , dessen Nutzung von 11,4 % im Jahr 2017 auf 28,8 % im Jahr 2018 zunahm. Der „Popularity of Programming Language Index“ ^{[ 160 ],} der Suchanfragen nach Sprachtutorials erfasst, listete Scala im April 2018 auf Platz 15 mit einem leichten Abwärtstrend und im Januar 2021 auf Platz 17. Damit ist Scala die drittbeliebteste JVM-basierte Sprache nach Java und Kotlin (Platz 12).

Im RedMonk Programming Language Ranking, das auf der Anzahl der GitHub -Projekte und der auf Stack Overflow gestellten Fragen basiert , wurde Scala im Januar 2021 auf Platz 14 eingestuft. [ ^{161 ] Hier} befand sich Scala in einer Gruppe von Sprachen der zweiten Reihe – vor Go , PowerShell und Haskell und hinter Swift , Objective-C , TypeScript und R.

Der TIOBE-Index ^{[ 162 ]} zur Messung der Popularität von Programmiersprachen verwendet Suchmaschinenrankings und ähnliche Publikationsstatistiken, um die Popularität einer Sprache zu ermitteln. Im September 2021 belegte Scala Platz 31. In dieser Rangliste lag Scala vor Haskell (Platz 38) und Erlang , aber hinter Go (Platz 14), Swift (Platz 15) und Perl (Platz 19).

Im Jahr 2022 belegten JVM-basierte Sprachen wie Clojure, Groovy und Scala zwar hohe Ränge, waren aber immer noch deutlich weniger populär als die ursprüngliche Programmiersprache Java , die üblicherweise unter den ersten drei Plätzen rangierte. ^{[ 161 ] [ 162 ]}

• Im April 2009 gab Twitter bekannt, dass es große Teile seines Backends von Ruby auf Scala umgestellt habe und beabsichtige, den Rest ebenfalls umzustellen. ^{[ 163 ]}
• Tesla, Inc. verwendet Akka mit Scala im Backend des Tesla Virtual Power Plant. Dabei wird das Actor-Modell zur Darstellung und zum Betrieb von Geräten verwendet, die zusammen mit anderen Komponenten eine Instanz des virtuellen Kraftwerks bilden, und Reactive Streams werden zur Datenerfassung und -verarbeitung eingesetzt. ^{[ 164 ]}
• Apache Kafka ist in Scala implementiert, wobei der Großteil des Kerns und anderer kritischer Teile in Scala implementiert ist. Es wird durch das Open-Source-Projekt und das Unternehmen Confluent gepflegt und erweitert. ^{[ 165 ]}
• Gilt verwendet Scala und das Play Framework . ^{[ 166 ]}
• Foursquare verwendet Scala und Lift . ^{[ 167 ]}
• Coursera verwendet Scala und das Play Framework . ^{[ 168 ]}
• Apple Inc. verwendet Scala in bestimmten Teams, zusammen mit Java und dem Play-Framework. ^{[ 169 ] [ 170 ]}
• Die vielbesuchte Website guardian.co.uk der Zeitung The Guardian ^{[ 171 ]} gab im April 2011 bekannt, dass sie von Java auf Scala umsteigt. ^{[ 172 ] [ 173 ]}
• Die New York Times gab 2014 bekannt, dass ihr internes Content-Management-System Blackbeard mit Scala, Akka und Playentwickelt wurde ^{. [ 174 ]}
• Die Zeitung Huffington Post begann 2013 mit dem Einsatz von Scala als Teil ihres Content-Delivery-Systems Athena. ^{[ 175 ]}
• Die Schweizer Bank UBS hat Scala für den allgemeinen Produktiveinsatz freigegeben. ^{[ 176 ]}
• LinkedIn nutzt das Scalatra- Mikroframework als Grundlage für seine Signal-API. ^{[ 177 ]}
• Meetup nutzt das Unfiltered Toolkit für Echtzeit-APIs. ^{[ 178 ]}
• Remember the Milk verwendet das Unfiltered Toolkit, Scala und Akka für die öffentliche API und Echtzeit-Updates. ^{[ 179 ]}
• Verizon strebt die Entwicklung eines „Frameworks der nächsten Generation“ mit Scala an. ^{[ 180 ]}
• Airbnb entwickelt die Open-Source-Software für maschinelles Lernen „Aerosolve“, die in Java und Scala geschrieben ist. ^{[ 181 ]}
• Zalando hat seinen Technologie-Stack von Java auf Scala und Play umgestellt. ^{[ 182 ]}
• SoundCloud nutzt Scala für sein Backend und verwendet dabei Technologien wie Finagle (Mikrodienste) ^{[ 183 ]} , Scalding und Spark (Datenverarbeitung). ^{[ 184 ]}
• Databricks verwendet Scala für die Apache Spark Big-Data-Plattform.
• Morgan Stanley nutzt Scala umfassend in seinen Finanz- und Vermögensprojekten. ^{[ 185 ]}
• Innerhalb von Google und Alphabet Inc. gibt es Teams , die Scala verwenden, hauptsächlich aufgrund von Übernahmen wie Firebase ^{[ 186 ]} und Nest. ^{[ 187 ]}
• Walmart Kanada nutzt Scala als Backend-Plattform. ^{[ 188 ]}
• Duolingo verwendet Scala für sein Backend-Modul, das Lektionen generiert. ^{[ 189 ]}
• HMRC nutzt Scala für viele Steueranwendungen der britischen Regierung. ^{[ 190 ]}
• M1 Finance nutzt Scala als Backend-Plattform. ^{[ 191 ]}
• Lichess verwendet Scala für seine Open-Source-Plattform-Kernanwendungen. ^{[ 192 ]}

Im November 2011 verabschiedete sich Yammer von Scala. Gründe hierfür waren unter anderem die steile Lernkurve für neue Teammitglieder und die Inkompatibilität zwischen verschiedenen Versionen des Scala-Compilers. ^{[ 193 ]} Im März 2015 erklärte Raffi Krikorian , ehemaliger Vizepräsident der Platform Engineering Group bei Twitter , dass er sich 2011 aufgrund der steilen Lernkurve nicht für Scala entschieden hätte . ^{[ 194 ]} Im selben Monat gab Kevin Scott , Senior Vice President von LinkedIn , die Entscheidung des Unternehmens bekannt, die Abhängigkeit von Scala zu minimieren. ^{[ 195 ]}

• sbt , ein weit verbreitetes Build-Tool für Scala-Projekte
• Das Spark Framework ist für die Verarbeitung großer Datenmengen konzipiert und unterstützt ausschließlich Scala.
• Neo4j ist ein Java-Spring-Framework, das von Scala unterstützt wird und über domänenspezifische Funktionalitäten, Analysefunktionen, Graphalgorithmen und vieles mehr verfügt.
• Play! ist ein Open-Source-Webanwendungsframework, das Scala unterstützt.
• Akka , ein Open-Source-Toolkit zum Erstellen von nebenläufigen und verteilten Anwendungen
• Chisel ist eine Open-Source-Sprache, die auf Scala basiert und für Hardware-Design und -Generierung verwendet wird. ^{[ 196 ]}