| Scala | |
|---|---|
 | |
| Paradigm | Multi-paradigm:concurrent,functional,imperative,object-oriented |
| Designed by | Martin Odersky |
| Developer | Programming Methods Laboratory ofÉcole Polytechnique Fédérale de Lausanne |
| First appeared | 20 January 2004; 21 years ago (2004-01-20) |
| Stable release | |
| Typing discipline | Inferred,static,strong,structural |
| Implementation language | Scala |
| Platform | Java virtual machine (JVM) JavaScript (Scala.js) LLVM (Scala Native) (experimental) |
| License | Apache 2.0[2] |
| Filename extensions | .scala, .sc |
| Website | www |
| Influenced by | |
| Common Lisp,[3]Eiffel,Erlang,Haskell,[4]Java,[5]OCaml,[5]Oz,Pizza,[6]Scheme,[5]Smalltalk,Standard ML[5] | |
| Influenced | |
| Ceylon,Chisel,Fantom,F#,C#,Kotlin,Lasso,Red,Flix | |
| |
Scala (/ˈskɑːlɑː/SKAH-lah)[7][8] is astronglystatically typedhigh-levelgeneral-purpose programming language that supports bothobject-oriented programming andfunctional programming. Designed to be concise,[9] many of Scala's design decisions are intended to addresscriticisms of Java.[6]
Scala source code can be compiled toJava bytecode and run on aJava virtual machine (JVM). Scala can also betranspiled toJavaScript to run in a browser, or compiled directly to a native executable. When running on the JVM, Scala provideslanguage interoperability withJava so that libraries written in either language may be referenced directly in Scala or Java code.[10] Like Java, Scala isobject-oriented, and uses asyntax termedcurly-brace which is similar to the languageC. Since Scala 3, there is also an option to use theoff-side rule (indenting) to structureblocks, and its use is advised.Martin Odersky has said that this turned out to be the most productive change introduced in Scala 3.[11]
Unlike Java, Scala has many features offunctional programming languages (likeScheme,Standard ML, andHaskell), includingcurrying,immutability,lazy evaluation, andpattern matching. It also has an advanced type system supportingalgebraic data types,covariance and contravariance,higher-order types (but nothigher-rank types),anonymous types,operator overloading,optional parameters,named parameters,raw strings, and an experimental exception-only version of algebraic effects that can be seen as a more powerful version of Java'schecked exceptions.[12]
The name Scala is a portmanteau ofscalable andlanguage, signifying that it is designed to grow with the demands of its users.[13]
The design of Scala started in 2001 at theÉcole Polytechnique Fédérale de Lausanne (EPFL) (inLausanne,Switzerland) byMartin Odersky. It followed on from work on Funnel, a programming language combining ideas from functional programming andPetri nets.[14] Odersky formerly worked onGeneric Java, andjavac, Sun's Java compiler.[14]
After an internal release in late 2003, Scala was released publicly in early 2004 on theJava platform,[15][6][14][16] A second version (v2.0) followed in March 2006.[6]
On 17 January 2011, the Scala team won a five-year research grant of over €2.3 million from theEuropean Research Council.[17] On 12 May 2011, Odersky and collaborators launched Typesafe Inc. (later renamedLightbend Inc.), a company to provide commercial support, training, and services for Scala. Typesafe received a $3 million investment in 2011 fromGreylock Partners.[18][19][20][21]
Scala runs on theJava platform (Java virtual machine) and is compatible with existingJava programs.[15] AsAndroid applications are typically written in Java and translated from Java bytecode intoDalvik bytecode (which may be further translated to native machine code during installation) when packaged, Scala's Java compatibility makes it well-suited to Android development, the more so when a functional approach is preferred.[22]
The reference Scala software distribution, including compiler and libraries, is released under theApache license.[23]
Scala.js is a Scala compiler that compiles to JavaScript, making it possible to write Scala programs that can run in web browsers orNode.js.[24] The compiler, in development since 2013, was announced as no longer experimental in 2015 (v0.6). Version v1.0.0-M1 was released in June 2018 and version 1.1.1 in September 2020.[25]
Scala Native is a Scalacompiler that targets theLLVM compiler infrastructure to create executable code that uses a lightweight managed runtime, which uses theBoehm garbage collector. The project is led by Denys Shabalin and had its first release, 0.1, on 14 March 2017. Development of Scala Native began in 2015 with a goal of being faster thanjust-in-time compilation for the JVM by eliminating the initial runtime compilation of code and also providing the ability to call native routines directly.[26][27]
A reference Scala compiler targeting the.NET Framework and itsCommon Language Runtime was released in June 2004,[14] but was officially dropped in 2012.[28]
TheHello World program written in Scala 3 has this form:
@maindefmain()=println("Hello, World!")
Unlike thestand-alone Hello World application for Java, there is no class declaration and nothing is declared to be static.
When the program is stored in fileHelloWorld.scala, the user compiles it with the command:
$ scalac HelloWorld.scala
and runs it with
$ scala HelloWorld
This is analogous to the process for compiling and running Java code. Indeed, Scala's compiling and executing model is identical to that of Java, making it compatible with Java build tools such asApache Ant.
A shorter version of the "Hello World" Scala program is:
println("Hello, World!")
Scala includes an interactive shell and scripting support.[29] Saved in a file namedHelloWorld2.scala, this can be run as a script using the command:
$ scala HelloWorld2.scala
Commands can also be entered directly into the Scala interpreter, using the option-e:
$ scala-e 'println("Hello, World!")'Expressions can be entered interactively in theREPL:
$scalaWelcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131).Type in expressions for evaluation. Or try :help.scala> List(1, 2, 3).map(x => x * x)res0: List[Int] = List(1, 4, 9)scala>
The following example shows the differences between Java and Scala syntax. The function mathFunction takes an integer, squares it, and then adds the cube root of that number to the natural log of that number, returning the result (i.e.,):
// Java:intmathFunction(intnum){intnumSquare=num*num;return(int)(Math.cbrt(numSquare)+Math.log(numSquare));} | |
// Scala: Direct conversion from Java// no import needed; scala.math// already imported as `math`defmathFunction(num:Int):Int=varnumSquare:Int=num*numreturn(math.cbrt(numSquare)+math.log(numSquare)).asInstanceOf[Int] | // Scala: More idiomatic// Uses type inference, omits `return` statement,// uses `toInt` method, declares numSquare immutableimportmath.*defmathFunction(num:Int)=valnumSquare=num*num(cbrt(numSquare)+log(numSquare)).toInt |
Some syntactic differences in this code are:
Int, Double, Boolean instead ofint, double, boolean.def.val (indicates animmutable variable) orvar (indicates amutable variable).return operator is unnecessary in a function (although allowed); the value of the last executed statement or expression is normally the function's value.(Type) foo, Scala usesfoo.asInstanceOf[Type], or a specialized function such astoDouble ortoInt.foo() can also be called as justfoo; methodthread.send(signo) can also be called as justthread send signo; and methodfoo.toString() can also be called as justfoo toString.These syntactic relaxations are designed to allow support fordomain-specific languages.
Some other basic syntactic differences:
array(i) rather thanarray[i]. (Internally in Scala, the former expands into array.apply(i) which returns the reference)List[String] rather than Java'sList<String>.void, Scala has the actualsingleton classUnit (see below).The following example contrasts the definition of classes in Java and Scala.
// Java:publicclassPoint{privatedoublex,y;publicPoint(doublex,doubley){this.x=x;this.y=y;}publicPoint(doublex,doubley,booleanaddToGrid){this(x,y);if(addToGrid)grid.addPoint(this);}publicPoint(){this(0.0,0.0);}privatevoidaddPoint(Pointp){x+=p.x;y+=p.y;}publicdoublegetX(){returnx;}publicdoublegetY(){returny;}doubledistanceToPoint(Pointother){returndistanceBetweenPoints(x,y,other.x,other.y);}privatestaticPointgrid=newPoint();staticdoubledistanceBetweenPoints(doublex1,doubley1,doublex2,doubley2){returnMath.hypot(x1-x2,y1-y2);}} | // ScalaclassPoint(varx:Double,vary:Double,addToGrid:Boolean=false):importPoint.*def+=(p:Point)=x+=p.xy+=p.yif(addToGrid)grid+=thisdefthis()=this(0.0,0.0)defdistanceToPoint(other:Point)=distanceBetweenPoints(x,y,other.x,other.y)endPointobjectPoint:privatevalgrid=newPoint()defdistanceBetweenPoints(x1:Double,y1:Double,x2:Double,y2:Double)=math.hypot(x1-x2,y1-y2) |
The code above shows some of the conceptual differences between Java and Scala's handling of classes:
object instead ofclass. It is common to place static variables and methods in a singleton object with the same name as the class name, which is then known as acompanion object.[15] (The underlying class for the singleton object has a$ appended. Hence, forclass Foo with companion objectobject Foo, under the hood there's a classFoo$ containing the companion object's code, and one object of this class is created, using thesingleton pattern.)val orvar modifier, fields are also defined with the same name, and automatically initialized from the class parameters. (Under the hood, external access to public fields always goes through accessor (getter) and mutator (setter) methods, which are automatically created. The accessor function has the same name as the field, which is why it's unnecessary in the above example to explicitly declare accessor methods.) Note that alternative constructors can also be declared, as in Java. Code that would go into thedefault constructor (other than initializing the member variables) goes directly at class level.addPoint, the Scala example defines+=, which is then invoked withinfix notation asgrid += this.public.Scala has the same compiling model asJava andC#, namely separate compiling anddynamic class loading, so that Scala code can call Java libraries.
Scala's operational characteristics are the same as Java's. The Scala compiler generates byte code that is nearly identical to that generated by the Java compiler.[15] In fact, Scala code can bedecompiled to readable Java code, with the exception of certain constructor operations. To theJava virtual machine (JVM), Scala code and Java code are indistinguishable. The only difference is one extra runtime library,scala-library.jar.[30]
Scala adds a large number of features compared with Java, and has some fundamental differences in its underlying model of expressions and types, which make the language theoretically cleaner and eliminate severalcorner cases in Java. From the Scala perspective, this is practically important because several added features in Scala are also available in C#.
As mentioned above, Scala has a good deal of syntactic flexibility, compared with Java. The following are some examples:
"%d apples".format(num) and"%d apples" format num are equivalent. In fact, arithmetic operators like+ and<< are treated just like any other methods, since function names are allowed to consist of sequences of arbitrary symbols (with a few exceptions made for things like parens, brackets and braces that must be handled specially); the only special treatment that such symbol-named methods undergo concerns the handling of precedence.apply andupdate have syntactic short forms.foo()—wherefoo is a value (singleton object or class instance)—is short forfoo.apply(), andfoo() = 42 is short forfoo.update(42). Similarly,foo(42) is short forfoo.apply(42), andfoo(4) = 2 is short forfoo.update(4, 2). This is used for collection classes and extends to many other cases, such asSTM cells.def foo = 42) and empty-parens (def foo() = 42) methods. When calling an empty-parens method, the parentheses may be omitted, which is useful when calling into Java libraries that do not know this distinction, e.g., usingfoo.toString instead offoo.toString(). By convention, a method should be defined with empty-parens when it performsside effects.:) expect the argument on the left-hand-side and the receiver on the right-hand-side. For example, the4 :: 2 :: Nil is the same asNil.::(2).::(4), the first form corresponding visually to the result (a list with first element 4 and second element 2).trait FooLike { var bar: Int }, an implementation may beobjectFooextendsFooLike{privatevarx=0;defbar=x;defbar_=(value:Int){x=value}}}}. The call site will still be able to use a concisefoo.bar = 42.breakable { ... if (...) break() ... } looks as ifbreakable was a language defined keyword, but really is just a method taking athunk argument. Methods that take thunks or functions often place these in a second parameter list, allowing to mix parentheses and curly braces syntax:Vector.fill(4) { math.random } is the same asVector.fill(4)(math.random). The curly braces variant allows the expression to span multiple lines.map,flatMap andfilter.By themselves, these may seem like questionable choices, but collectively they serve the purpose of allowingdomain-specific languages to be defined in Scala without needing to extend the compiler. For example,Erlang's special syntax for sending a message to an actor, i.e.actor ! message can be (and is) implemented in a Scala library without needing language extensions.
Java makes a sharp distinction between primitive types (e.g.int andboolean) and reference types (anyclass). Only reference types are part of the inheritance scheme, deriving fromjava.lang.Object. In Scala, all types inherit from a top-level classAny, whose immediate children areAnyVal (value types, such asInt andBoolean) andAnyRef (reference types, as in Java). This means that the Java distinction between primitive types and boxed types (e.g.int vs.Integer) is not present in Scala;boxing and unboxing is completely transparent to the user. Scala 2.10 allows for new value types to be defined by the user.
Instead of the Java "foreach" loops for looping through an iterator, Scala hasfor-expressions, which are similar tolist comprehensions in languages such asHaskell, or a combination of list comprehensions andgenerator expressions inPython. For-expressions using theyield keyword allow a newcollection to be generated by iterating over an existing one, returning a new collection of the same type. They are translated by the compiler into a series ofmap,flatMap andfilter calls. Whereyield is not used, the code approximates to an imperative-style loop, by translating toforeach.
A simple example is:
vals=for(x<-1to25ifx*x>50)yield2*x
The result of running it is the following vector:
Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)(Note that the expression1 to 25 is not special syntax. The methodto is rather defined in the standard Scala library as an extension method on integers, using a technique known as implicit conversions[32] that allows new methods to be added to existing types.)
A more complex example of iterating over a map is:
// Given a map specifying Twitter users mentioned in a set of tweets,// and number of times each user was mentioned, look up the users// in a map of known politicians, and return a new map giving only the// Democratic politicians (as objects, rather than strings).valdem_mentions=for(mention,times)<-mentionsaccount<-accounts.get(mention)ifaccount.party=="Democratic"yield(account,times)
Expression(mention, times) <- mentions is an example ofpattern matching (see below). Iterating over a map returns a set of key-valuetuples, and pattern-matching allows the tuples to easily be destructured into separate variables for the key and value. Similarly, the result of the comprehension also returns key-value tuples, which are automatically built back up into a map because the source object (from the variablementions) is a map. Note that ifmentions instead held a list, set, array or other collection of tuples, exactly the same code above would yield a new collection of the same type.
While supporting all of the object-oriented features available in Java (and in fact, augmenting them in various ways), Scala also provides a large number of capabilities that are normally found only infunctional programming languages. Together, these features allow Scala programs to be written in an almost completely functional style and also allow functional and object-oriented styles to be mixed.
Examples are:
UnlikeC orJava, but similar to languages such asLisp, Scala makes no distinction between statements andexpressions. All statements are in fact expressions that evaluate to some value. Functions that would be declared as returningvoid in C or Java, and statements likewhile that logically do not return a value, are in Scala considered to return the typeUnit, which is asingleton type, with only one object of that type. Functions and operators that never return at all (e.g. thethrow operator or a function that always exitsnon-locally using an exception) logically have return typeNothing, a special type containing no objects; that is, abottom type, i.e. a subclass of every possible type. (This in turn makes typeNothing compatible with every type, allowingtype inference to function correctly.)[33]
Similarly, anif-then-else "statement" is actually an expression, which produces a value, i.e. the result of evaluating one of the two branches. This means that such a block of code can be inserted wherever an expression is desired, obviating the need for aternary operator in Scala:
// Java:charhexDigit=(char)(x>=10?x+'A'-10:x+'0'); | // Scala:valhexDigit=(ifx>=10thenx+'A'-10elsex+'0').toChar |
For similar reasons,return statements are unnecessary in Scala, and in fact are discouraged. As inLisp, the last expression in a block of code is the value of that block of code, and if the block of code is the body of a function, it will be returned by the function.
To make it clear that all functions are expressions, even methods that returnUnit are written with an equals sign
defprintValue(x:String):Unit=println("I ate a %s".format(x))
or equivalently (with type inference, and omitting the unnecessary newline):
defprintValue(x:String)=println("I ate a %s"formatx)
Due totype inference, the type of variables, function return values, and many other expressions can typically be omitted, as the compiler can deduce it. Examples areval x = "foo" (for an immutableconstant orimmutable object) orvar x = 1.5 (for a variable whose value can later be changed). Type inference in Scala is essentially local, in contrast to the more globalHindley-Milner algorithm used in Haskell,ML and other more purely functional languages. This is done to facilitate object-oriented programming. The result is that certain types still need to be declared (most notably, function parameters, and the return types ofrecursive functions), e.g.
defformatApples(x:Int)="I ate %d apples".format(x)
or (with a return type declared for a recursive function)
deffactorial(x:Int):Int=ifx==0then1elsex*factorial(x-1)
In Scala, functions are objects, and a convenient syntax exists for specifyinganonymous functions. An example is the expressionx => x < 2, which specifies a function with one parameter, that compares its argument to see if it is less than 2. It is equivalent to the Lisp form(lambda(x)(<x2)). Note that neither the type ofx nor the return type need be explicitly specified, and can generally be inferred bytype inference; but they can be explicitly specified, e.g. as(x:Int)=>x<2 or even(x:Int)=>(x<2):Boolean.
Anonymous functions behave as trueclosures in that they automatically capture any variables that are lexically available in the environment of the enclosing function. Those variables will be available even after the enclosing function returns, and unlike in the case of Java'sanonymous inner classes do not need to be declared as final. (It is even possible to modify such variables if they are mutable, and the modified value will be available the next time the anonymous function is called.)
An even shorter form of anonymous function usesplaceholder variables: For example, the following:
list map { x => sqrt(x) }can be written more concisely as
list map { sqrt(_) }or even
list map sqrtScala enforces a distinction between immutable and mutable variables. Mutable variables are declared using thevar keyword and immutable values are declared using theval keyword.A variable declared using theval keyword cannot be reassigned in the same way that a variable declared using thefinal keyword can't be reassigned in Java.vals are only shallowly immutable, that is, an object referenced by a val is not guaranteed to itself be immutable.
Immutable classes are encouraged by convention however, and the Scala standard library provides a rich set of immutablecollection classes.Scala provides mutable and immutable variants of most collection classes, and the immutable version is always used unless the mutable version is explicitly imported.[34]The immutable variants arepersistent data structures that always return an updated copy of an old object instead of updating the old object destructively in place.An example of this isimmutable linked lists where prepending an element to a list is done by returning a new list node consisting of the element and a reference to the list tail.Appending an element to a list can only be done by prepending all elements in the old list to a new list with only the new element.In the same way, inserting an element in the middle of a list will copy the first half of the list, but keep a reference to the second half of the list. This is called structural sharing.This allows for very easy concurrency — no locks are needed as no shared objects are ever modified.[35]
Evaluation is strict ("eager") by default. In other words, Scala evaluates expressions as soon as they are available, rather than as needed. However, it is possible to declare a variable non-strict ("lazy") with thelazy keyword, meaning that the code to produce the variable's value will not be evaluated until the first time the variable is referenced. Non-strict collections of various types also exist (such as the typeStream, a non-strict linked list), and any collection can be made non-strict with theview method. Non-strict collections provide a good semantic fit to things like server-produced data, where the evaluation of the code to generate later elements of a list (that in turn triggers a request to a server, possibly located somewhere else on the web) only happens when the elements are actually needed.
Functional programming languages commonly providetail call optimization to allow for extensive use ofrecursion withoutstack overflow problems. Limitations in Java bytecode complicate tail call optimization on the JVM. In general, a function that calls itself with a tail call can be optimized, but mutually recursive functions cannot.Trampolines have been suggested as a workaround.[36] Trampoline support has been provided by the Scala library with the objectscala.util.control.TailCalls since Scala 2.8.0 (released 14 July 2010). A function may optionally be annotated with@tailrec, in which case it will not compile unless it is tail recursive.[37]
An example of this optimization could be implemented using thefactorial definition. For instance, the recursive version of the factorial:
deffactorial(n:Int):Int=ifn==0then1elsen*factorial(n-1)
Could be optimized to the tail recursive version like this:
@tailrecdeffactorial(n:Int,accum:Int):Int=ifn==0thenaccumelsefactorial(n-1,n*accum)
However, this could compromise composability with other functions because of the new argument on its definition, so it is common to useclosures to preserve its original signature:
deffactorial(n:Int):Int=@tailrecdefloop(current:Int,accum:Int):Int=ifcurrent==0thenaccumelseloop(current-1,current*accum)loop(n,1)// Call to the closure using the base caseendfactorial
This ensures tail call optimization and thus prevents a stack overflow error.
Scala has built-in support forpattern matching, which can be thought of as a more sophisticated, extensible version of aswitch statement, where arbitrary data types can be matched (rather than just simple types like integers, Booleans and strings), including arbitrary nesting. A special type of class known as acase class is provided, which includes automatic support for pattern matching and can be used to model thealgebraic data types used in many functional programming languages. (From the perspective of Scala, a case class is simply a normal class for which the compiler automatically adds certain behaviors that could also be provided manually, e.g., definitions of methods providing for deep comparisons and hashing, and destructuring a case class on its constructor parameters during pattern matching.)
An example of a definition of thequicksort algorithm using pattern matching is this:
defqsort(list:List[Int]):List[Int]=listmatchcaseNil=>Nilcasepivot::tail=>val(smaller,rest)=tail.partition(_<pivot)qsort(smaller):::pivot::qsort(rest)
The idea here is that we partition a list into the elements less than a pivot and the elements not less, recursively sort each part, and paste the results together with the pivot in between. This uses the samedivide-and-conquer strategy ofmergesort and other fast sorting algorithms.
Thematch operator is used to do pattern matching on the object stored inlist. Eachcase expression is tried in turn to see if it will match, and the first match determines the result. In this case,Nil only matches the literal objectNil, butpivot :: tail matches a non-empty list, and simultaneouslydestructures the list according to the pattern given. In this case, the associated code will have access to a local variable namedpivot holding the head of the list, and another variabletail holding the tail of the list. Note that these variables are read-only, and are semantically very similar to variablebindings established using thelet operator in Lisp and Scheme.
Pattern matching also happens in local variable declarations. In this case, the return value of the call totail.partition is atuple — in this case, two lists. (Tuples differ from other types of containers, e.g. lists, in that they are always of fixed size and the elements can be of differing types — although here they are both the same.) Pattern matching is the easiest way of fetching the two parts of the tuple.
The form_ < pivot is a declaration of ananonymous function with a placeholder variable; see the section above on anonymous functions.
The list operators:: (which adds an element onto the beginning of a list, similar tocons in Lisp and Scheme) and::: (which appends two lists together, similar toappend in Lisp and Scheme) both appear. Despite appearances, there is nothing "built-in" about either of these operators. As specified above, any string of symbols can serve as function name, and a method applied to an object can be written "infix"-style without the period or parentheses. The line above as written:
qsort(smaller) ::: pivot :: qsort(rest)could also be written thus:
qsort(rest).::(pivot).:::(qsort(smaller))in more standard method-call notation. (Methods that end with a colon are right-associative and bind to the object to the right.)
In the pattern-matching example above, the body of thematch operator is apartial function, which consists of a series ofcase expressions, with the first matching expression prevailing, similar to the body of aswitch statement. Partial functions are also used in the exception-handling portion of atry statement:
try...catchcasenfe:NumberFormatException=>{println(nfe);List(0)}case_=>Nil
Finally, a partial function can be used alone, and the result of calling it is equivalent to doing amatch over it. For example, the prior code forquicksort can be written thus:
valqsort:List[Int]=>List[Int]=caseNil=>Nilcasepivot::tail=>val(smaller,rest)=tail.partition(_<pivot)qsort(smaller):::pivot::qsort(rest)
Here a read-onlyvariable is declared whose type is a function from lists of integers to lists of integers, and bind it to a partial function. (Note that the single parameter of the partial function is never explicitly declared or named.) However, we can still call this variable exactly as if it were a normal function:
scala>qsort(List(6,2,5,9))res32:List[Int]=List(2,5,6,9)
Scala is a pureobject-oriented language in the sense that every value is anobject.Data types and behaviors of objects are described byclasses andtraits. Class abstractions are extended bysubclassing and by a flexiblemixin-based composition mechanism to avoid the problems ofmultiple inheritance.
Traits are Scala's replacement for Java'sinterfaces. Interfaces in Java versions under 8 are highly restricted, able only to contain abstract function declarations. This has led to criticism that providing convenience methods in interfaces is awkward (the same methods must be reimplemented in every implementation), and extending a published interface in a backwards-compatible way is impossible. Traits are similar tomixin classes in that they have nearly all the power of a regular abstract class, lacking only class parameters (Scala's equivalent to Java's constructor parameters), since traits are always mixed in with a class. Thesuper operator behaves specially in traits, allowing traits to be chained using composition in addition to inheritance. The following example is a simple window system:
abstractclassWindow:// abstractdefdraw()classSimpleWindowextendsWindow:defdraw()println("in SimpleWindow")// draw a basic windowtraitWindowDecorationextendsWindowtraitHorizontalScrollbarDecorationextendsWindowDecoration:// "abstract override" is needed here for "super()" to work because the parent// function is abstract. If it were concrete, regular "override" would be enough.abstractoverridedefdraw()println("in HorizontalScrollbarDecoration")super.draw()// now draw a horizontal scrollbartraitVerticalScrollbarDecorationextendsWindowDecoration:abstractoverridedefdraw()println("in VerticalScrollbarDecoration")super.draw()// now draw a vertical scrollbartraitTitleDecorationextendsWindowDecoration:abstractoverridedefdraw()println("in TitleDecoration")super.draw()// now draw the title bar
A variable may be declared thus:
valmywin=newSimpleWindowwithVerticalScrollbarDecorationwithHorizontalScrollbarDecorationwithTitleDecoration
The result of callingmywin.draw() is:
inTitleDecorationinHorizontalScrollbarDecorationinVerticalScrollbarDecorationinSimpleWindow
In other words, the call todraw first executed the code inTitleDecoration (the last trait mixed in), then (through thesuper() calls) threaded back through the other mixed-in traits and eventually to the code inWindow,even though none of the traits inherited from one another. This is similar to thedecorator pattern, but is more concise and less error-prone, as it doesn't require explicitly encapsulating the parent window, explicitly forwarding functions whose implementation isn't changed, or relying on run-time initialization of entity relationships. In other languages, a similar effect could be achieved at compile-time with a long linear chain ofimplementation inheritance, but with the disadvantage compared to Scala that one linear inheritance chain would have to be declared for each possible combination of the mix-ins.
Scala is equipped with an expressive static type system that mostly enforces the safe and coherent use of abstractions. The type system is, however, notsound.[38] In particular, the type system supports:
Scala is able toinfer types by use. This makes most static type declarations optional. Static types need not be explicitly declared unless a compiler error indicates the need. In practice, some static type declarations are included for the sake of code clarity.
A common technique in Scala, known as "enrich my library"[39] (originally termed "pimp my library" by Martin Odersky in 2006;[32] concerns were raised about this phrasing due to its negative connotations[40] and immaturity[41]), allows new methods to be used as if they were added to existing types. This is similar to the C# concept ofextension methods but more powerful, because the technique is not limited to adding methods and can, for instance, be used to implement new interfaces. In Scala, this technique involves declaring animplicit conversion from the type "receiving" the method to a new type (typically, a class) that wraps the original type and provides the additional method. If a method cannot be found for a given type, the compiler automatically searches for any applicable implicit conversions to types that provide the method in question.
This technique allows new methods to be added to an existing class using an add-on library such that only code thatimports the add-on library gets the new functionality, and all other code is unaffected.
The following example shows the enrichment of typeInt with methodsisEven andisOdd:
objectMyExtensions:extension(i:Int)defisEven=i%2==0defisOdd=!i.isEvenimportMyExtensions.*// bring implicit enrichment into scope4.isEven// -> true
Importing the members ofMyExtensions brings the implicit conversion to extension classIntPredicates into scope.[42]
Scala's standard library includes support forfutures and promises, in addition to the standard Java concurrency APIs. Originally, it also included support for theactor model, which is now available as a separatesource-available platformAkka[43] licensed byLightbend Inc. Akka actors may bedistributed or combined withsoftware transactional memory (transactors). Alternativecommunicating sequential processes (CSP) implementations for channel-based message passing are Communicating Scala Objects,[44] or simply viaJCSP.
An Actor is like a thread instance with a mailbox. It can be created bysystem.actorOf, overriding thereceive method to receive messages and using the! (exclamation point) method to send a message.[45]The following example shows an EchoServer that can receive messages and then print them.
valechoServer=actor(newAct:become:casemsg=>println("echo "+msg))echoServer!"hi"
Scala also comes with built-in support for data-parallel programming in the form of Parallel Collections[46] integrated into its Standard Library since version 2.9.0.
The following example shows how to use Parallel Collections to improve performance.[47]
valurls=List("https://scala-lang.org","https://github.com/scala/scala")deffromURL(url:String)=scala.io.Source.fromURL(url).getLines().mkString("\n")valt=System.currentTimeMillis()urls.par.map(fromURL(_))// par returns parallel implementation of a collectionprintln("time: "+(System.currentTimeMillis-t)+"ms")
Besides futures and promises, actor support, anddata parallelism, Scala also supports asynchronous programming with software transactional memory, and event streams.[48]
The most well-known open-source cluster-computing solution written in Scala isApache Spark. Additionally,Apache Kafka, thepublish–subscribemessage queue popular with Spark and other stream processing technologies, is written in Scala.
There are several ways to test code in Scala. ScalaTest supports multiple testing styles and can integrate with Java-based testing frameworks.[49] ScalaCheck is a library similar to Haskell'sQuickCheck.[50] specs2 is a library for writing executable software specifications.[51] ScalaMock provides support for testing high-order and curried functions.[52]JUnit andTestNG are popular testing frameworks written in Java.
| Version | Released | Features |
|---|---|---|
| 1.0.0-b2[53] | 8 December 2003 | — |
| 1.1.0-b1[53] | 19 February 2004 |
|
| 1.1.1[53] | 23 March 2004 |
|
| 1.2.0[53] | 9 June 2004 |
|
| 1.3.0[53] | 16 September 2004 |
|
| 1.4.0[53] | 20 June 2005 |
|
| 2.0[55] | 12 March 2006 |
|
| 2.1.0[53] | 17 March 2006 |
|
| 2.1.8[56] | 23 August 2006 |
|
| 2.3.0[57] | 23 November 2006 |
|
| 2.4.0[58] | 9 March 2007 |
|
| 2.5.0[59] | 2 May 2007 |
|
| 2.6.0[60] | 27 July 2007 |
|
| 2.7.0[61] | 7 February 2008 |
|
| 2.8.0[62] | 14 Jul 2010 |
|
| 2.9.0[63] | 12 May 2011 |
|
| 2.10[64] | 4 January 2013 |
Experimental features |
| 2.10.2[74] | 6 June 2013 | — |
| 2.10.3[75] | 1 October 2013 | — |
| 2.10.4[76] | 18 March 2014 | — |
| 2.10.5[77] | 5 March 2015 | — |
| 2.11.0[78] | 21 April 2014 |
|
| 2.11.1[79] | 20 May 2014 | — |
| 2.11.2[80] | 22 July 2014 | — |
| 2.11.4[81] | 31 October 2014 | — |
| 2.11.5[82] | 8 January 2015 | — |
| 2.11.6[83] | 5 March 2015 | — |
| 2.11.7[84] | 23 June 2015 | — |
| 2.11.8[85] | 8 March 2016 | — |
| 2.11.11[86] | 18 April 2017 | — |
| 2.11.12[87] | 13 November 2017 | — |
| 2.12.0[88] | 3 November 2016 |
|
| 2.12.1[89] | 5 December 2016 | — |
| 2.12.2[86] | 18 April 2017 | — |
| 2.12.3[90] | 26 July 2017 | — |
| 2.12.4[91] | 17 October 2017 | — |
| 2.12.5[92] | 15 March 2018 | — |
| 2.12.6[93] | 27 April 2018 | — |
| 2.12.7[94] | 27 September 2018 | — |
| 2.12.8[95] | 4 December 2018 |
|
| 2.12.9[96] | 5 August 2019 | — |
| 2.12.10[97] | 10 September 2019 | — |
| 2.12.11[98] | 16 March 2020 | — |
| 2.12.12[99] | 13 July 2020 | — |
| 2.12.13[100] | 12 January 2021 | — |
| 2.12.14[101] | 28 May 2021 | — |
| 2.12.15[102] | 14 Sep 2021 | — |
| 2.12.16[103] | 10 June 2022 | — |
| 2.12.17[104] | 16 September 2022 | — |
| 2.12.18[105] | 7 June 2023 | — |
| 2.12.19[106] | 25 February 2024 | — |
| 2.13.0[107] | 11 June 2019 |
|
| 2.13.1[108] | 18 September 2019 | — |
| 2.13.2[109] | 22 April 2020 | — |
| 2.13.3[110] | 25 June 2020 | — |
| 2.13.4[111] | 19 November 2020 | — |
| 2.13.5[112] | 22 February 2021 | — |
| 2.13.6[113] | 17 May 2021 | — |
| 2.13.7[114] | 1 November 2021 | — |
| 2.13.8[115] | 12 January 2022 | — |
| 2.13.9[116] | 21 September 2022 | — |
| 2.13.10[117] | 13 October 2022 | — |
| 2.13.11[118] | 7 June 2023 | — |
| 2.13.12[119] | 11 September 2023 | — |
| 2.13.13[120] | 26 February 2024 | — |
| 2.13.14[121] | 1 May 2024 | — |
| 2.13.15[122] | 25 Sep 2024 | — |
| 3.0.0[123] | 13 May 2021 | — |
| 3.0.1[124] | 31 July 2021 | — |
| 3.0.2[125] | 7 September 2021 | — |
| 3.1.0[126] | 21 October 2021 | — |
| 3.1.1[127] | 1 February 2022 | — |
| 3.1.2[128] | 12 April 2022 | — |
| 3.1.3[129] | 21 June 2022 | — |
| 3.2.0[130] | 5 September 2022 | — |
| 3.2.1[131] | 7 November 2022 | — |
| 3.2.2[132] | 30 January 2023 | — |
| 3.3.0[133] | 30 May 2023 | — |
| 3.3.1[134] | 7 September 2023 | — |
| 3.3.2[135] | 29 February 2024 | — |
| 3.3.3[136] | 29 February 2024 | — |
| 3.4.0[136] | 29 February 2024 | — |
| 3.4.1[137] | 29 March 2024 | — |
| 3.4.2[138] | 16 May 2024 | — |
Scala is often compared withGroovy andClojure, two other programming languages also using the JVM. Substantial differences between these languages exist in the type system, in the extent to which each language supports object-oriented and functional programming, and in the similarity of their syntax to that of Java.
Scala isstatically typed, while both Groovy and Clojure aredynamically typed. This makes the type system more complex and difficult to understand but allows almost all[38] type errors to be caught at compile-time and can result in significantly faster execution. By contrast, dynamic typing requires more testing to ensure program correctness, and thus is generally slower, to allow greater programming flexibility and simplicity. Regarding speed differences, current versions of Groovy and Clojure allow optional type annotations to help programs avoid the overhead of dynamic typing in cases where types are practically static. This overhead is further reduced when using recent versions of the JVM, which has been enhanced with aninvoke dynamic instruction for methods that are defined with dynamically typed arguments. These advances reduce the speed gap between static and dynamic typing, although a statically typed language, like Scala, is still the preferred choice when execution efficiency is very important.
Regarding programming paradigms, Scala inherits the object-oriented model of Java and extends it in various ways. Groovy, while also strongly object-oriented, is more focused in reducing verbosity. In Clojure, object-oriented programming is deemphasised with functional programming being the main strength of the language. Scala also has many functional programming facilities, including features found in advanced functional languages like Haskell, and tries to be agnostic between the two paradigms, letting the developer choose between the two paradigms or, more frequently, some combination thereof.
Regarding syntax similarity with Java, Scala inherits much of Java's syntax, as is the case with Groovy. Clojure on the other hand follows theLisp syntax, which is different in both appearance and philosophy.[citation needed]
Back in 2013, when Scala was in version 2.10, theThoughtWorks Technology Radar, which is an opinion based biannual report of a group of senior technologists,[139] recommended Scala adoption in its languages and frameworks category.[140]
In July 2014, this assessment was made more specific and now refers to a “Scala, the good parts”, which is described as “To successfully use Scala, you need to research the language and have a very strong opinion on which parts are right for you, creating your own definition of Scala, the good parts.”.[141]
In the 2018 edition of theState ofJava survey,[142] which collected data from 5160 developers on various Java-related topics, Scala places third in terms of use of alternative languages on theJVM. Relative to the prior year's edition of the survey, Scala's use among alternativeJVM languages fell from 28.4% to 21.5%, overtaken byKotlin, which rose from 11.4% in 2017 to 28.8% in 2018.The Popularity of Programming Language Index,[143] which tracks searches for language tutorials, ranked Scala 15th in April 2018 with a small downward trend, and 17th in Jan 2021. This makes Scala the 3rd most popular JVM-based language afterJava and Kotlin, ranked 12th.
TheRedMonk Programming Language Rankings, which establishes rankings based on the number ofGitHub projects and questions asked onStack Overflow, in January 2021 ranked Scala 14th.[144] Here, Scala was placed inside a second-tier group of languages–ahead ofGo,PowerShell, and Haskell, and behindSwift,Objective-C,TypeScript, andR.
TheTIOBE index[145] of programming language popularity employs internet search engine rankings and similar publication counting to determine language popularity. In September 2021, it showed Scala in 31st place. In this ranking, Scala was ahead of Haskell (38th) andErlang, but belowGo (14th),Swift (15th), andPerl (19th).
As of 2022[update], JVM-based languages such as Clojure, Groovy, and Scala are highly ranked, but still significantly less popular than the originalJava language, which is usually ranked in the top three places.[144][145]
In November 2011,Yammer moved away from Scala for reasons that included the learning curve for new team members and incompatibility from one version of the Scala compiler to the next.[175] In March 2015, former VP of the Platform Engineering group atTwitterRaffi Krikorian, stated that he would not have chosen Scala in 2011 due to itslearning curve.[176] The same month,LinkedIn SVPKevin Scott stated their decision to "minimize [their] dependence on Scala".[177]
The creators of Scala actually pronounce itscah-lah, like the Italian word for "stairs." The two "a"s are pronounced the same.
if orwhile cannot be re-implemented. There is a research project, Scala-Virtualized, that aimed at removing these restrictions: Adriaan Moors, Tiark Rompf, Philipp Haller and Martin Odersky.Scala-Virtualized.Proceedings of the ACM SIGPLAN 2012 workshop on Partial evaluation and program manipulation, 117–120. July 2012.Also known as pimp-my-library pattern
implicit def IntPredicate(i: Int) = new IntPredicate(i). The class can also be defined asimplicit class IntPredicates(val i: Int) extends AnyVal { ... }, producing a so-calledvalue class, also introduced in Scala 2.10. The compiler will then eliminate actual instantiations and generate static methods instead, allowing extension methods to have virtually no performance overhead.What I would have done differently four years ago is use Java and not used Scala as part of this rewrite. [...] it would take an engineer two months before they're fully productive and writing Scala code.[permanent dead link]
| Platforms |
| _waving.svg) | |||||
|---|---|---|---|---|---|---|---|
| Technologies |
| ||||||
| History | |||||||
| JVM languages | |||||||
| Community |
| ||||||
| International | |
|---|---|
| National | |
| Other | |
