SUPPORT THE WORK
GetWiki
Scala (programming language)
ARTICLE SUBJECTS
being →
database →
ethics →
fiction →
history →
internet →
language →
linux →
logic →
method →
news →
policy →
purpose →
religion →
science →
software →
truth →
unix →
wiki →
ARTICLE TYPES
essay →
feed →
help →
system →
wiki →
ARTICLE ORIGINS
critical →
forked →
imported →
original →
Scala (programming language)
please note:
- the content below is remote from Wikipedia
- it has been imported raw for GetWiki
{{Short description|General-purpose programming language}}{{For|the music scale creation software|Scala (software)}}- the content below is remote from Wikipedia
- it has been imported raw for GetWiki
| factoids | |
|---|---|
History
The design of Scala started in 2001 at the École Polytechnique Fédérale de Lausanne (EPFL) (in Lausanne, Switzerland) by Martin Odersky. It followed on from work on Funnel, a programming language combining ideas from functional programming and Petri nets.WEB, Odersky, Martin, 9 June 2006,weblink A Brief History of Scala, Artima.com, Odersky formerly worked on Generic Java, and javac, Sun's Java compiler.After an internal release in late 2003, Scala was released publicly in early 2004 on the Java platform,JOURNAL, Odersky, M., Rompf, T., 2014, Unifying functional and object-oriented programming with Scala, Communications of the ACM, 57, 4, 76, 10.1145/2591013, free, Martin Odersky, "The Scala Language Specification Version 2.7" A second version (v2.0) followed in March 2006.On 17 January 2011, the Scala team won a five-year research grant of over €2.3 million from the European Research Council.WEB,weblink Scala Team Wins ERC Grant, 4 July 2015, On 12 May 2011, Odersky and collaborators launched Typesafe Inc. (later renamed Lightbend Inc.), a company to provide commercial support, training, and services for Scala. Typesafe received a $3 million investment in 2011 from Greylock Partners.WEB,weblink Commercial Support for Scala, 2011-05-12, 2011-08-18, WEB,weblink Why We Invested in Typesafe: Modern Applications Demand Modern Tools, 2011-05-12, 2018-05-08, WEB,weblink Open-source Scala gains commercial backing, 2011-05-12, 2011-10-09, WEB,weblink Cloud computing pioneer Martin Odersky takes wraps off his new company Typesafe, 2011-05-12, 2011-08-24,Platforms and license
Scala runs on the Java platform (Java virtual machine) and is compatible with existing Java programs. As Android applications are typically written in Java and translated from Java bytecode into Dalvik 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.WEB,weblink Scala on Android, 8 June 2016, 20 June 2016,weblink" title="web.archive.org/web/20160620223823weblink">weblink dead, The reference Scala software distribution, including compiler and libraries, is released under the Apache license.WEB,weblink Scala 2.12.8 is now available!, 2018-12-04, 2018-12-09,Other compilers and targets
Scala.js is a Scala compiler that compiles to JavaScript, making it possible to write Scala programs that can run in web browsers or Node.js.WEB,weblink Scala Js Is No Longer Experimental | The Scala Programming Language, Scala-lang.org, 28 October 2015, 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.WEB,weblink Releases · scala-js/Scala-js, GitHub, Scala Native is a Scala compiler that targets the LLVM compiler infrastructure to create executable code that uses a lightweight managed runtime, which uses the Boehm 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 than just-in-time compilation for the JVM by eliminating the initial runtime compilation of code and also providing the ability to call native routines directly.NEWS, Krill, Paul, 15 March 2017,weblink Scaled-down Scala variant cuts ties to the JVM, InfoWorld, 21 March 2017, NEWS, Krill, Paul, 2016-05-11,weblink Scala language moves closer to bare metal, InfoWorld, A reference Scala compiler targeting the .NET Framework and its Common Language Runtime was released in June 2004, but was officially dropped in 2012.Expunged the .net backend. by paulp · Pull Request #1718 · scala/scala · GitHub. Github.com (2012-12-05). Retrieved on 2013-11-02.Examples
"Hello World" example
The Hello World program written in Scala 3 has this form:@main def main() = println("Hello, World!")Unlike the stand-alone Hello World application for Java, there is no class declaration and nothing is declared to be static.When the program is stored in file HelloWorld.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 as Apache Ant.A shorter version of the "Hello World" Scala program is:println("Hello, World!")Scala includes an interactive shell and scripting support.WEB,weblink Getting Started with Scala, 15 July 2008, Scala-lang.org, 31 July 2014, Saved in a file named HelloWorld2.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 {{mono|-e}}:
$ scala -e 'println("Hello, World!")'
Expressions can be entered interactively in the REPL:$ 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> Basic example
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., n^{2/3} + ln(n^2)):{|
int numSquare = num*num;
return (int) (Math.cbrt(numSquare) +
Math.log(numSquare));
}return (int) (Math.cbrt(numSquare) +
Math.log(numSquare));
var numSquare: Int = num*num
return (math.cbrt(numSquare) + math.log(numSquare)).
asInstanceOf[Int]
| // Scala: More idiomatic// Uses type inference, omits `return` statement,// uses `toInt` method, declares numSquare immutableimport math._def mathFunction(num: Int) =
return (math.cbrt(numSquare) + math.log(numSquare)).
asInstanceOf[Int]
val numSquare = num*num
(cbrt(numSquare) + log(numSquare)).toInt
(cbrt(numSquare) + log(numSquare)).toInt
- Scala does not require semicolons (;) to end statements.
- Value types are capitalized (sentence case): Int, Double, Boolean instead of int, double, boolean.
- Parameter and return types follow, as in Pascal, rather than precede as in C.
- Methods must be preceded by def.
- Local or class variables must be preceded by val (indicates an immutable variable) or var (indicates a mutable variable).
- The return operator is unnecessary in a function (although allowed); the value of the last executed statement or expression is normally the function's value.
- Instead of the Java cast operator (Type) foo, Scala uses foo.asInstanceOf[Type], or a specialized function such as toDouble or toInt.
- Instead of Java's import foo.;, Scala uses import foo._.
- Function or method foo() can also be called as just foo; method thread.send(signo) can also be called as just thread send signo; and method foo.toString() can also be called as just foo toString.
- Array references are written like function calls, e.g. array(i) rather than array[i]. (Internally in Scala, the former expands into array.apply(i) which returns the reference)
- Generic types are written as e.g. List[String] rather than Java's List
. - Instead of the pseudo-type void, Scala has the actual singleton class Unit (see below).
Example with classes
The following example contrasts the definition of classes in Java and Scala.{|
private double x, y;
public Point(final double x, final double y) {
this.x = x;
this.y = y;
}
public Point(final double x, final double y) {
this.x = x;
this.y = y;
}
public Point(
double x, double y,
boolean addToGrid
) {
this(x, y);
double x, double y,
boolean addToGrid
) {
this(x, y);
if (addToGrid)
grid.addPoint(this);
}
grid.addPoint(this);
}
public Point() {
this(0.0, 0.0);
}
this(0.0, 0.0);
}
private void addPoint(Point p) {
x += p.x;
y += p.y;
}
x += p.x;
y += p.y;
}
public double getX() {
return x;
}
return x;
}
public double getY() {
return y;
}
return y;
}
double distanceToPoint(final Point other) {
return distanceBetweenPoints(x, y,
other.x, other.y);
}
return distanceBetweenPoints(x, y,
other.x, other.y);
}
private static Point grid = new Point();
static double distanceBetweenPoints(
final double x1, final double y1,
final double x2, final double y2
) {
return Math.hypot(x1 - x2, y1 - y2);
}
}| // Scalaclass Point(
final double x1, final double y1,
final double x2, final double y2
) {
return Math.hypot(x1 - x2, y1 - y2);
}
var x: Double, var y: Double,
addToGrid: Boolean = false
):
addToGrid: Boolean = false
import Point._
def += (p: Point) =
x += p.x
y += p.y
def += (p: Point) =
x += p.x
y += p.y
if (addToGrid)
grid += this
grid += this
def this() = this(0.0, 0.0)
def distanceToPoint(other: Point) =
distanceBetweenPoints(x, y, other.x, other.y)
end Pointobject Point:
distanceBetweenPoints(x, y, other.x, other.y)
private val grid = new Point()
def distanceBetweenPoints(x1: Double, y1: Double,
x2: Double, y2: Double) =
math.hypot(x1 - x2, y1 - y2)
x2: Double, y2: Double) =
math.hypot(x1 - x2, y1 - y2)
- Scala has no static variables or methods. Instead, it has singleton objects, which are essentially classes with only one instance. Singleton objects are declared using object instead of class. 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 a companion object. (The underlying class for the singleton object has a $ appended. Hence, for class Foo with companion object object Foo, under the hood there's a class Foo$ containing the companion object's code, and one object of this class is created, using the singleton pattern.)
- In place of constructor parameters, Scala has class parameters, which are placed on the class, similar to parameters to a function. When declared with a val or var 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 the default constructor (other than initializing the member variables) goes directly at class level.
- In Scala it is possible to define operators by using symbols as method names. In place of addPoint, the Scala example defines +=, which is then invoked with infix notation as grid += this.
- Default visibility in Scala is public.
Features (with reference to Java)
Scala has the same compiling model as Java and C#, namely separate compiling and dynamic 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. In fact, Scala code can be decompiled to readable Java code, with the exception of certain constructor operations. To the Java virtual machine (JVM), Scala code and Java code are indistinguishable. The only difference is one extra runtime library, scala-library.jar.WEB,weblink Home, Blog.lostlake.org, 2013-06-25, dead,weblink" title="web.archive.org/web/20100831041226weblink">weblink 31 August 2010, 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 several corner cases in Java. From the Scala perspective, this is practically important because several added features in Scala are also available in C#.Syntactic flexibility
As mentioned above, Scala has a good deal of syntactic flexibility, compared with Java. The following are some examples:- Semicolons are unnecessary; lines are automatically joined if they begin or end with a token that cannot normally come in this position, or if there are unclosed parentheses or brackets.
- Any method can be used as an infix operator, e.g. "%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.
- Methods apply and update have syntactic short forms. foo()—where foo is a value (singleton object or class instance)—is short for foo.apply(), and foo() = 42 is short for foo.update(42). Similarly, foo(42) is short for foo.apply(42), and foo(4) = 2 is short for foo.update(4, 2). This is used for collection classes and extends to many other cases, such as STM cells.
- Scala distinguishes between no-parens (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., using foo.toString instead of foo.toString(). By convention, a method should be defined with empty-parens when it performs side effects.
- Method names ending in colon (:) expect the argument on the left-hand-side and the receiver on the right-hand-side. For example, the 4 :: 2 :: Nil is the same as Nil.::(2).::(4), the first form corresponding visually to the result (a list with first element 4 and second element 2).
- Class body variables can be transparently implemented as separate getter and setter methods. For trait FooLike { var bar: Int }, an implementation may be {{code|2=scala|1=object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value {{)}}{{)}} } } }}. The call site will still be able to use a concise foo.bar = 42.
- The use of curly braces instead of parentheses is allowed in method calls. This allows pure library implementations of new control structures.Scala's built-in control structures such as if or while 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. For example, breakable { ... if (...) break() ... } looks as if breakable was a language defined keyword, but really is just a method taking a thunk 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 as Vector.fill(4)(math.random). The curly braces variant allows the expression to span multiple lines.
- For-expressions (explained further down) can accommodate any type that defines monadic methods such as map, flatMap and filter.
Unified type system
Java makes a sharp distinction between primitive types (e.g. int and boolean) and reference types (any class). Only reference types are part of the inheritance scheme, deriving from java.lang.Object. In Scala, all types inherit from a top-level class Any, whose immediate children are AnyVal (value types, such as Int and Boolean) and AnyRef (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.For-expressions
Instead of the Java "foreach" loops for looping through an iterator, Scala has for-expressions, which are similar to list comprehensions in languages such as Haskell, or a combination of list comprehensions and generator expressions in Python. For-expressions using the yield keyword allow a new collection 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 of map, flatMap and filter calls. Where yield is not used, the code approximates to an imperative-style loop, by translating to foreach.A simple example is:val s = for (x 50) yield 2*xThe 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 expression 1 to 25 is not special syntax. The method to is rather defined in the standard Scala library as an extension method on integers, using a technique known as implicit conversionsWEB,weblink Pimp my Library, Artima.com, 2006-10-09, 2013-06-25, 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).val dem_mentions = for
(mention, times) = 10 then x + 'A' - 10 else x + '0').toChar
For similar reasons, return statements are unnecessary in Scala, and in fact are discouraged. As in Lisp, 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 return Unit are written with an equals signdef printValue(x: String): Unit =
println("I ate a %s".format(x))
or equivalently (with type inference, and omitting the unnecessary newline):def printValue(x: String) = println("I ate a %s" format x)Type inference
Due to type inference, the type of variables, function return values, and many other expressions can typically be omitted, as the compiler can deduce it. Examples are val x = "foo" (for an immutable constant or immutable object) or var x = 1.5 (for a variable whose value can later be changed). Type inference in Scala is essentially local, in contrast to the more global Hindley-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 of recursive functions), e.g.def formatApples(x: Int) = "I ate %d apples".format(x)or (with a return type declared for a recursive function)def factorial(x: Int): Int =
if x == 0 then 1
else x * factorial(x - 1)
else x * factorial(x - 1)
Anonymous functions
In Scala, functions are objects, and a convenient syntax exists for specifying anonymous functions. An example is the expression x => 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) (< x 2)). Note that neither the type of x nor the return type need be explicitly specified, and can generally be inferred by type 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 true closures 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's anonymous 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 uses placeholder variables: For example, the following:
list map { x => sqrt(x) }
can be written more concisely as
list map { sqrt(_) }
or even
list map sqrt
Immutability
Scala enforces a distinction between immutable and mutable variables. Mutable variables are declared using the var keyword and immutable values are declared using the val keyword.A variable declared using the val keyword cannot be reassigned in the same way that a variable declared using the final 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 immutable collection 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.WEB,weblink Mutable and Immutable Collections - Scala Documentation, 30 April 2020, The immutable variants are persistent 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 is immutable 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.WEB,weblink Collections - Concrete Immutable Collection Classes - Scala Documentation, 4 July 2015,Lazy (non-strict) evaluation
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 the lazy 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 type Stream, a non-strict linked list), and any collection can be made non-strict with the view 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.Tail recursion
Functional programming languages commonly provide tail call optimization to allow for extensive use of recursion without stack 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.WEB,weblink Rich Dougherty's blog, Rich, Dougherty, 4 July 2015, Trampoline support has been provided by the Scala library with the object scala.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.WEB,weblink$.html, TailCalls - Scala Standard Library API (Scaladoc) 2.10.2 - scala.util.control.TailCalls, Scala-lang.org, 2013-06-25, An example of this optimization could be implemented using the factorial definition. For instance, the recursive version of the factorial: def factorial(n: Int): Int =
if n == 0 then 1
else n * factorial(n - 1)
Could be optimized to the tail recursive version like this: @tailrecdef factorial(n: Int, accum: Int): Int =
else n * factorial(n - 1)
if n == 0 then accum
else factorial(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 use closures to preserve its original signature: def factorial(n: Int): Int =
else factorial(n - 1, n * accum)
@tailrec
def loop(current: Int, accum: Int): Int =
if n == 0 then accum
else loop(current - 1, n * accum)
loop(n, 1) // Call to the closure using the base case
end factorial
def loop(current: Int, accum: Int): Int =
if n == 0 then accum
else loop(current - 1, n * accum)
loop(n, 1) // Call to the closure using the base case
Case classes and pattern matching
Scala has built-in support for pattern matching, which can be thought of as a more sophisticated, extensible version of a switch 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 a case class is provided, which includes automatic support for pattern matching and can be used to model the algebraic 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 the quicksort algorithm using pattern matching is this: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)
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 same divide-and-conquer strategy of mergesort and other fast sorting algorithms.The match operator is used to do pattern matching on the object stored in list. Each case 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 object Nil, but pivot :: tail matches a non-empty list, and simultaneously destructures the list according to the pattern given. In this case, the associated code will have access to a local variable named pivot holding the head of the list, and another variable tail holding the tail of the list. Note that these variables are read-only, and are semantically very similar to variable bindings established using the let operator in Lisp and Scheme.Pattern matching also happens in local variable declarations. In this case, the return value of the call to tail.partition is a tuple — 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 an anonymous 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 to cons in Lisp and Scheme) and ::: (which appends two lists together, similar to append 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:
case pivot :: tail =>
val (smaller, rest) = tail.partition(_ < pivot)
qsort(smaller) ::: pivot :: qsort(rest)
qsort(smaller) ::: pivot :: qsort(rest)
qsort(rest).::(pivot).:::(qsort(smaller))
Partial functions
In the pattern-matching example above, the body of the match operator is a partial function, which consists of a series of case expressions, with the first matching expression prevailing, similar to the body of a switch statement. Partial functions are also used in the exception-handling portion of a try statement:try
...
catch
case nfe: 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 a match over it. For example, the prior code for quicksort can be written thus:val qsort: List[Int] => List[Int] =
case _ => Nil
case Nil => Nil
case pivot :: tail =>
val (smaller, rest) = tail.partition(_ < pivot)
qsort(smaller) ::: pivot :: qsort(rest)
Here a read-only variable 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)case pivot :: tail =>
val (smaller, rest) = tail.partition(_ < pivot)
qsort(smaller) ::: pivot :: qsort(rest)
Object-oriented extensions
Scala is a pure object-oriented language in the sense that every value is an object. Data types and behaviors of objects are described by classes and traits. Class abstractions are extended by subclassing and by a flexible mixin-based composition mechanism to avoid the problems of multiple inheritance.Traits are Scala's replacement for Java's interfaces. 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 to mixin 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. The super operator behaves specially in traits, allowing traits to be chained using composition in addition to inheritance. The following example is a simple window system:abstract class Window:
// abstract
def draw()
class SimpleWindow extends Window:
def draw()
def draw()
println("in SimpleWindow")
// draw a basic window
trait WindowDecoration extends Windowtrait HorizontalScrollbarDecoration extends WindowDecoration:
println("in SimpleWindow")
// draw a basic window
// "abstract override" is needed here for "super()" to work because the parent
// function is abstract. If it were concrete, regular "override" would be enough.
abstract override def draw()
println("in HorizontalScrollbarDecoration")
super.draw()
// now draw a horizontal scrollbar
trait VerticalScrollbarDecoration extends WindowDecoration:
// function is abstract. If it were concrete, regular "override" would be enough.
abstract override def draw()
println("in HorizontalScrollbarDecoration")
super.draw()
// now draw a horizontal scrollbar
abstract override def draw()
println("in VerticalScrollbarDecoration")
super.draw()
// now draw a vertical scrollbar
trait TitleDecoration extends WindowDecoration:
println("in VerticalScrollbarDecoration")
super.draw()
// now draw a vertical scrollbar
abstract override def draw()
println("in TitleDecoration")
super.draw()
// now draw the title bar
A variable may be declared thus:val mywin = new SimpleWindow with VerticalScrollbarDecoration with HorizontalScrollbarDecoration with TitleDecorationThe result of calling mywin.draw() is:in TitleDecorationin HorizontalScrollbarDecorationin VerticalScrollbarDecorationin SimpleWindowIn other words, the call to draw first executed the code in TitleDecoration (the last trait mixed in), then (through the super() calls) threaded back through the other mixed-in traits and eventually to the code in Window, even though none of the traits inherited from one another. This is similar to the decorator 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 of implementation 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.println("in TitleDecoration")
super.draw()
// now draw the title bar
Expressive type system
Scala is equipped with an expressive static type system that mostly enforces the safe and coherent use of abstractions. The type system is, however, not sound. In particular, the type system supports:- Classes and abstract types as object members
- Structural types
- Path-dependent types
- Compound types
- Explicitly typed self references
- Generic classes
- Polymorphic methods
- Upper and lower type bounds
- Variance
- Annotation
- Views
Type enrichment
A common technique in Scala, known as "enrich my library"CONFERENCE, 1210.6284, Reify your collection queries for modularity and speed!, Giarrusso, Paolo G., 2013, ACM, Proceedings of the 12th annual international conference on Aspect-oriented software development, Also known as pimp-my-library pattern, 2012arXiv1210.6284G, (originally termed "pimp my library" by Martin Odersky in 2006; concerns were raised about this phrasing due to its negative connotationsWEB,weblink What is highest priority for Scala to succeed in corporate world (Should be in scala-debate?) ?, Gilbert, Clint, 2011-11-15, Scala-lang.org, 2019-05-08, and immaturityWEB,weblink Should we "enrich" or "pimp" Scala libraries?, 17 June 2013, stackexchange.com, 15 April 2016, ), allows new methods to be used as if they were added to existing types. This is similar to the C# concept of extension 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 an implicit 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 that imports the add-on library gets the new functionality, and all other code is unaffected.The following example shows the enrichment of type Int with methods isEven and isOdd:object MyExtensions:
extension (i: Int)
def isEven = i % 2 == 0
def isOdd = !isEven
import MyExtensions._ // bring implicit enrichment into scope4.isEven // -> trueImporting the members of MyExtensions brings the implicit conversion to extension class IntPredicates into scope.Implicit classes were introduced in Scala 2.10 to make method extensions more concise. This is equivalent to adding a method implicit def IntPredicate(i: Int) = new IntPredicate(i). The class can also be defined as implicit class IntPredicates(val i: Int) extends AnyVal { ... }, producing a so-called value 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.def isEven = i % 2 == 0
def isOdd = !isEven
Concurrency
Scala's standard library includes support for futures and promises, in addition to the standard Java concurrency APIs. Originally, it also included support for the actor model, which is now available as a separate source-available platform AkkaWhat is Akka?, Akka online documentation licensed by Lightbend Inc. Akka actors may be distributed or combined with software transactional memory (transactors). Alternative communicating sequential processes (CSP) implementations for channel-based message passing are Communicating Scala Objects,BOOK, Sufrin, Bernard, 2008, Communicating Scala Objects, Welch, P. H., Stepney, S., Polack, F.A.C., Barnes, F. R. M., McEwan, A.A., Stiles, G.S., Broenink, J. F., Sampson, A. T.,weblink Communicating Process Architectures 2008: WoTUG-31, IOS Press, 978-1586039073, or simply via JCSP.An Actor is like a thread instance with a mailbox. It can be created by system.actorOf, overriding the receive method to receive messages and using the ! (exclamation point) method to send a message.WEB,weblink Scala Tour, Kay, Yan, 4 July 2015, The following example shows an EchoServer that can receive messages and then print them.val echoServer = actor(new Act:
become:
case msg => println("echo " + msg)
)echoServer ! "hi"Scala also comes with built-in support for data-parallel programming in the form of Parallel CollectionsWEB,weblink Parallelcollections - Overview - Scala Documentation, Docs.scala-lang.org, 2013-06-25, integrated into its Standard Library since version 2.9.0.The following example shows how to use Parallel Collections to improve performance.WEB,weblink Scala Tour, Kay, Yan, 4 July 2015, val urls = List("https://scala-lang.org", "https://github.com/scala/scala")def fromURL(url: String) = scala.io.Source.fromURL(url)
case msg => println("echo " + msg)
.getLines().mkString("n")
val t = System.currentTimeMillis()urls.par.map(fromURL(_)) // par returns parallel implementation of a collectionprintln("time: " + (System.currentTimeMillis - t) + "ms")Besides futures and promises, actor support, and data parallelism, Scala also supports asynchronous programming with software transactional memory, and event streams.Learning Concurrent Programming in Scala, Aleksandar Prokopec, Packt PublishingCluster computing
The most well-known open-source cluster-computing solution written in Scala is Apache Spark. Additionally, Apache Kafka, the publish–subscribe message queue popular with Spark and other stream processing technologies, is written in Scala.Testing
There are several ways to test code in Scala. ScalaTest supports multiple testing styles and can integrate with Java-based testing frameworks.WEB,weblink A short Introduction to ScalaTest, Kops, Micha, 2013-01-13, hascode.com, 2014-11-07, ScalaCheck is a library similar to Haskell's QuickCheck.WEB,weblink ScalaCheck 1.5, Nilsson, Rickard, 2008-11-17, Scala-lang.org, 2014-11-07, specs2 is a library for writing executable software specifications.WEB,weblink Build web applications using Scala and the Play Framework, 2013-05-22, workwithplay.com, 2014-11-07, ScalaMock provides support for testing high-order and curried functions.WEB,weblink ScalaMock 3.0 Preview Release, Butcher, Paul, 2012-06-04, paulbutcher.com, 2014-11-07, 2014-11-08,weblink" title="web.archive.org/web/20141108064050weblink">weblink dead, JUnit and TestNG are popular testing frameworks written in Java.Versions {| class"wikitable"
- scala.Enumeration
- Scala license was changed to the revised BSD license
- Support for Java static inner classes
- Library class improvements to Iterable, Array, xml.Elem, Buffer
- Views
- XML literals (to "be dropped in the near future, to be replaced with XML string interpolation"WEB, Dropped: XML Literals,weblink 2021-03-05, dotty.epfl.ch, )
- Support for Microsoft .NET
- Method closures
- Type syntax for parameterless methods changed from [] T to => T
- Attributes
- match keyword replaces match method
- Experimental support for runtime types
- Compiler completely rewritten in Scala
- Experimental support for Java generics
- implicit and requires keywords
- match keyword only allowed infix operator
- with connective is only allowed following an extends clause
- Newlines can be used as statement separators in place of semicolons
- Regular expression match patterns restricted to sequence patterns only
- For-comprehensions admit value and pattern definitions
- Class parameters may be prefixed by val or var
- Private visibility has qualifiers
- sbaz tool integrated in the Scala distribution
- match keyword replaces match method
- Experimental support for runtime types
- Protected visibility has qualifiers
- Private members of a class can be referenced from the companion module of the class and vice versa
- Implicit lookup generalised
- Typed pattern match tightened for singleton types
- Functions returning Unit don't have to explicitly state a return type
- Type variables and types are distinguished between in pattern matching
- All and AllRef renamed to Nothing and Null
- private and protected modifiers accept a [this] qualifier
- Tuples can be written with round brackets
- Primary constructor of a class can now be marked private or protected
- Attributes changed to annotations with new syntax
- Self aliases
- Operators can be combined with assignment
- Type parameters and abstract type members can also abstract over type constructors
- Fields of an object can be initialized before parent constructors are called
- Syntax change for comprehensions
- Implicit anonymous functions (with underscores for parameters)
- Pattern matching of anonymous functions extended to support any arty
- Existential types
- Lazy values
- Structural types
- Java generic types supported by default
- Case classes functionality extended
- Revision the common, uniform, and all-encompassing framework for collection types.
- Type specialisation
- Named and default arguments
- Package objects
- Improved annotations
- Parallel collections
- Thread safe App trait replaces Application trait
- DelayedInit trait
- Java interop improvements
- Value classesWEB,weblink Value Classes and Universal Traits, Harrah, Mark, Scala-lang.org, 2014-11-07,
- Implicit classesWEB,weblink SIP-13 - Implicit classes, Suereth, Josh, Scala-lang.org, 2014-11-07, 2014-11-08,weblink" title="web.archive.org/web/20141108075739weblink">weblink dead,
- String interpolationWEB,weblink String Interpolation, Suereth, Josh, Scala-lang.org, 2014-11-07,
- Futures and promisesWEB,weblink Futures and Promises, Haller, Philipp, Prokopec, Aleksandar, Scala-lang.org, 2014-11-07,
- Dynamic and applyDynamicWEB,weblink SIP-17 - Type Dynamic, Scala-lang.org, 2014-11-07, 2014-11-08,weblink" title="web.archive.org/web/20141108080051weblink">weblink dead,
- Dependent method types:
- def identity(x: AnyRef): x.type = x // the return type says we return exactly what we got
- New bytecode emitter based on ASM:
- Can target JDK 1.5, 1.6 and 1.7
- Emits 1.6 bytecode by default
- Old 1.5 backend is deprecated
- A new pattern matcher: rewritten from scratch to generate more robust code (no more exponential blow-up)
- code generation and analyses are now independent (the latter can be turned off with -Xno-patmat-analysis)
- Scaladoc improvements
- Implicits (-implicits flag)
- Diagrams (-diagrams flag, requires graphviz)
- Groups (-groups)
- Modularized language featuresWEB,weblink SIP-18 - Modularizing Language Features, Scala-lang.org, 2014-11-07, 2014-11-08,weblink" title="web.archive.org/web/20141108075841weblink">weblink dead,
- Parallel collectionsWEB,weblink Parallel Collections, Prokopec, Aleksandar, Miller, Heather, Scala-lang.org, 2014-11-07, are now configurable with custom thread pools
- Akka actors now part of the distribution
- scala.actors have been deprecated and the akka implementation is now included in the distribution.
- Performance improvements
- Faster inliner
- Rangesum is now O(1)
- Update of ForkJoin library
- Fixes in immutable TreeSet/TreeMap
- Improvements to PartialFunctions
- Addition of ??? and NotImplementedError
- Addition of IsTraversableOnce + IsTraversableLike type classes for extension methods
- Deprecations and cleanup
- Floating point and octal literal syntax deprecation
- Removed scala.dbc
- Collection performance improvements
- Compiler performance improvements
- Java 8 required
- Java 8 bytecode generated
- Java 8 SAM (Functional interface) language support
- First Scala 2.12 release with the license changed to Apache v2.0
- Standard collections library redesigned
- Literal types
- Partial type unification
- By-name implicits
- Compiler optimizations
Comparison with other JVM languages
Scala is often compared with Groovy and Clojure, 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 is statically typed, while both Groovy and Clojure are dynamically typed. This makes the type system more complex and difficult to understand but allows almost allWEB,weblink Java and Scala's Type Systems are Unsound, 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 an invoke 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 the Lisp syntax, which is different in both appearance and philosophy.{{Citation needed|date=October 2015}}Adoption
Language rankings
Back in 2013, when Scala was in version 2.10, the ThoughtWorks Technology Radar, which is an opinion based biannual report of a group of senior technologists,NEWS, ThoughtWorks Technology Radar FAQ,weblink recommended Scala adoption in its languages and frameworks category.NEWS, ThoughtWorks Technology Radar MAY 2013,weblink 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.â€.NEWS, Scala, the good parts,weblink In the 2018 edition of the State of Java survey,NEWS, The State of Java in 2018,weblink which collected data from 5160 developers on various Java-related topics, Scala places third in terms of use of alternative languages on the JVM. Relative to the prior year's edition of the survey, Scala's use among alternative JVM languages fell from 28.4% to 21.5%, overtaken by Kotlin, which rose from 11.4% in 2017 to 28.8% in 2018.The Popularity of Programming Language Index,NEWS, Popularity of Programming Language Index,weblink 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 after Java and Kotlin, ranked 12th.The RedMonk Programming Language Rankings, which establishes rankings based on the number of GitHub projects and questions asked on Stack Overflow, in January 2021 ranked Scala 14th.NEWS, O'Grady, Stephen, 1 March 2021, The RedMonk Programming Language Rankings: January 2021,weblink RedMonk, Here, Scala was placed inside a second-tier group of languages–ahead of Go, PowerShell, and Haskell, and behind Swift, Objective-C, Typescript, and R.The TIOBE index 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) and Erlang, but below Go (14th), Swift (15th), and Perl (19th).{{As of|2022}}, JVM-based languages such as Clojure, Groovy, and Scala are highly ranked, but still significantly less popular than the original Java language, which is usually ranked in the top three places.NEWS, TIOBE Index for May 2021,weblink {{clear}}Companies
- In April 2009, Twitter announced that it had switched large portions of its backend from Ruby to Scala and intended to convert the rest.WEB
, Greene
, Kate
, The Secret Behind Twitter's Growth, How a new Web programming language is helping the company handle its increasing popularity
, Technology Review
, MIT
, 1 April 2009
,weblink
, 6 April 2009,
, Kate
, The Secret Behind Twitter's Growth, How a new Web programming language is helping the company handle its increasing popularity
, Technology Review
, MIT
, 1 April 2009
,weblink
, 6 April 2009,
- Tesla, Inc. uses Akka with Scala in the backend of the Tesla Virtual Power Plant. Thereby, the Actor model is used for representing and operating devices that together with other components make up an instance of the virtual power plant, and Reactive Streams are used for data collection and data processing.WEB,weblink Breck, Colin, Link, Percy, Tesla Virtual Power Plant (Architecture and Design), 2020-03-23, 2023-03-28,
- Apache Kafka is implemented in Scala with regards to most of its core and other critical parts. It is maintained and extended through the open source project and by the company Confluent.WEB,weblink Apache Kafka source code at GitHub, Apache Software Foundation, 29 March 2023,
- Gilt uses Scala and Play Framework.WEB,weblink Play Framework, Akka and Scala at Gilt Groupe, 15 July 2013, Lightbend, 16 July 2016,
- Foursquare uses Scala and Lift.WEB,weblink Scala, Lift, and the Future, 4 July 2015, dead,weblink" title="web.archive.org/web/20160113201402weblink">weblink 13 January 2016,
- Coursera uses Scala and Play Framework.WEB, Saeta, Brennan,weblink Why we love Scala at Coursera, Coursera Engineering, 2014-02-17, 2023-09-21,
- Apple Inc. uses Scala in certain teams, along with Java and the Play framework.WEB,weblink Apple Engineering PM Jarrod Nettles on Twitter, Jarrod Nettles, 2016-03-11, WEB,weblink 30 Scala job openings at Apple, Alvin Alexander, 2016-03-11,
- The Guardian newspaper's high-traffic website guardian.co.ukNEWS, David Reid, Tania Teixeira, amp,weblink Are people ready to pay for online news?, BBC, 2010-02-28, 26 February 2010, announced in April 2011 that it was switching from Java to Scala.WEB,weblink Guardian switching from Java to Scala, 2011-04-05, 2011-04-05, Heise Online, WEB,weblink Guardian.co.uk Switching from Java to Scala, InfoQ.com, 2011-04-04, 2011-04-05,
- The New York Times revealed in 2014 that its internal content management system Blackbeard is built using Scala, Akka, and Play.NEWS, Roy, Suman, Sundaresan, Krishna, 2014-05-13,weblink Building Blackbeard: A Syndication System Powered By Play, Scala and Akka, The New York Times, 2014-07-20,
- The Huffington Post newspaper started to employ Scala as part of its content delivery system Athena in 2013.NEWS, Pavley, John, 2013-08-11,weblink Sneak Peek: HuffPost Brings Real Time Collaboration to the Newsroom, Huffington Post, 2014-07-20,
- Swiss bank UBS approved Scala for general production use.NEWS, Binstock, Andrew, 2011-07-14,weblink Interview with Scala's Martin Odersky, Dr. Dobb's Journal, 2012-02-10,
- LinkedIn uses the Scalatra microframework to power its Signal API.NEWS, Synodinos, Dionysios G., 2010-10-11,weblink LinkedIn Signal: A Case Study for Scala, JRuby and Voldemort, InfoQ,
- Meetup uses Unfiltered toolkit for real-time APIs.WEB,weblink Real-life Meetups Deserve Real-time APIs,
- Remember the Milk uses Unfiltered toolkit, Scala and Akka for public API and real-time updates.WEB,weblink Real time updating comes to the Remember The Milk web app,
- Verizon seeking to make "a next-generation framework" using Scala.WEB,weblink WHAT IS SCALA, 8 March 2023, 2023-03-17,
- Airbnb develops open-source machine-learning software "Aerosolve", written in Java and Scala.WEB,weblink Airbnb announces Aerosolve, an open-source machine learning software package, 2015-06-04, Novet, Jordan, 2016-03-09,
- Zalando moved its technology stack from Java to Scala and Play.WEB,weblink Kops, Alexander, Zalando Tech: From Java to Scala in Less Than Three Months, 2015-12-14, 2016-03-09,
- SoundCloud uses Scala for its back-end, employing technologies such as Finagle (micro services),WEB,weblink Calçado, Phil, Building Products at SoundCloud—Part III: Microservices in Scala and Finagle, 2014-06-13, 2016-03-09, Scalding and Spark (data processing).WEB,weblink Concurrent Inc., Customer Case Studies: SoundCloud, 2014-11-18, 2016-03-09,
- Databricks uses Scala for the Apache Spark Big Data platform.
- Morgan Stanley uses Scala extensively in their finance and asset-related projects.AV MEDIA, 2015-12-03, Scala at Morgan Stanley, video, en,weblink 2016-03-11, Skills Matter,
- There are teams within Google and Alphabet Inc. that use Scala, mostly due to acquisitions such as FirebaseAV MEDIA, Greg Soltis, 2015-12-03, SF Scala, Greg Soltis: High Performance Services in Scala, video, en,weblinkweblink 2021-12-21, live, 2016-03-11, Skills Matter, {{cbignore}} and Nest.WEB,weblink Lee Mighdoll, Scala jobs at Nest, 2016-03-11,
- Walmart Canada uses Scala for their back-end platform.WEB,weblink Nurun, Nurun Launches Redesigned Transactional Platform With Walmart Canada, 2013-12-11,
- Duolingo uses Scala for their back-end module that generates lessons.WEB, Rewriting Duolingo's engine in Scala,weblink Horie, André K., 2017-01-31, 2017-02-03,
- HMRC uses Scala for many UK Government tax applications.WEB, HMRC GitHub repository, GitHub,weblink
- M1 Finance uses Scala for their back-end platform.WEB,weblink Meet M1 Finance, A ScalaCon Gold Sponsor, 2023-09-02, ScalaCon, en,
Criticism
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.WEB,weblink The Rest of the Story, Hale, Coda, 29 November 2011, codahale.com, 7 November 2013, In March 2015, former VP of the Platform Engineering group at Twitter Raffi Krikorian, stated that he would not have chosen Scala in 2011 due to its learning curve.AV MEDIA, Krikorian, Raffi, 17 March 2015, O'Reilly Software Architecture Conference 2015 Complete Video Compilation: Re-Architecting on the Fly - Raffi Krikorian - Part 3, video,weblink 8 March 2016, 4:57, O'Reilly Media, 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., {{Dead link|date=November 2023 |bot=InternetArchiveBot |fix-attempted=yes }} The same month, LinkedIn SVP Kevin Scott stated their decision to "minimize [their] dependence on Scala".WEB,weblink Is LinkedIn getting rid of Scala?, Scott, Kevin, 11 Mar 2015, quora.com, 25 January 2016,See also
- sbt, a widely used build tool for Scala projects
- Spark Framework is designed to handle, and process big-data and it solely supports Scala
- Neo4j is a java spring framework supported by Scala with domain-specific functionality, analytical capabilities, graph algorithms, and many more
- Play!, an open-source Web application framework that supports Scala
- Akka, an open-source toolkit for building concurrent and distributed applications
- Chisel, an open-source language built on Scala that is used for hardware design and generation.WEB, Chisel: Constructing Hardware in a Scala Embedded Language,weblink UC Berkeley APSIRE, 27 May 2020,
References
{{Reflist|30em}}Further reading
- BOOK, Martin, Odersky, Lex, Spoon, Bill, Venners, 15 December 2019, Programming in Scala: A Comprehensive Step-by-step Guide, Artima Inc, 4th, 896, 978-0-9815316-1-8,weblink
- BOOK, Cay, Horstmann, 15 December 2016, Scala for the Impatient, Addison-Wesley Professional, 2nd, 384, 978-0-134-54056-6,weblink
- BOOK, Dean, Wampler, Alex, Payne, 14 December 2014, Programming Scala: Scalability = Functional Programming + Objects, O'Reilly Media, 2nd, 583, 978-1-491-94985-6,weblink
- BOOK, Joshua D., Suereth, Spring 2011, Scala in Depth,weblink limited, Manning Publications, 225, 978-1-935182-70-2
- BOOK, Gregory, Meredith, 2011, Monadic Design Patterns for the Web, 1st, 300,weblink
- BOOK, Martin, Odersky, Lex, Spoon, Bill, Venners, 10 December 2008, Programming in Scala, eBook, 1st, Artima Inc,weblink
- content above as imported from Wikipedia
- "Scala (programming language)" does not exist on GetWiki (yet)
- time: 7:13am EDT - Sat, May 18 2024
- "Scala (programming language)" does not exist on GetWiki (yet)
- time: 7:13am EDT - Sat, May 18 2024
[ this remote article is provided by Wikipedia ]
LATEST EDITS [ see all ]
GETWIKI 23 MAY 2022
The Illusion of Choice
Culture
Culture
GETWIKI 09 JUL 2019
Eastern Philosophy
History of Philosophy
History of Philosophy
GETWIKI 09 MAY 2016
GetMeta:About
GetWiki
GetWiki
GETWIKI 18 OCT 2015
M.R.M. Parrott
Biographies
Biographies
GETWIKI 20 AUG 2014
GetMeta:News
GetWiki
GetWiki
CONNECT
© 2024 M.R.M. PARROTT | ALL RIGHTS RESERVED