Scala in a Nutshell
Click the buttons to see Scala in action, or visit the Scala Documentation to learn more.
Seamless Java Interop
Scala runs on the JVM, so Java and Scala stacks can be freely mixed for totally seamless integration.
Type Inference
So the type system doesn’t feel so static. Don’t work for the type system. Let the type system work for you!
Concurrency & Distribution
Use data-parallel operations on collections, use actors for concurrency and distribution, or futures for asynchronous programming.
class Author(val firstName: String,
val lastName: String) extends Comparable[Author] {
override def compareTo(that: Author) = {
val lastNameComp = this.lastName compareTo that.lastName
if (lastNameComp != 0) lastNameComp
else this.firstName compareTo that.firstName
}
}
object Author {
def loadAuthorsFromFile(file: java.io.File): List[Author] = ???
}import static scala.collection.JavaConversions.asJavaCollection;
public class App {
public List<Author> loadAuthorsFromFile(File file) {
return new ArrayList<Author>(asJavaCollection(
Author.loadAuthorsFromFile(file)));
}
public void sortAuthors(List<Author> authors) {
Collections.sort(authors);
}
public void displaySortedAuthors(File file) {
List<Author> authors = loadAuthorsFromFile(file);
sortAuthors(authors);
for (Author author : authors) {
System.out.println(
author.lastName() + ", " + author.firstName());
}
}
}Combine Scala and Java seamlessly
Scala classes are ultimately JVM classes. You can create Java objects, call their methods and inherit from Java classes transparently from Scala. Similarly, Java code can reference Scala classes and objects.
In this example, the Scala class Author implements the Java
interface Comparable<T> and works with Java
Files. The Java code uses a method from the companion object
Author, and accesses fields of the Author class.
It also uses JavaConversions to convert between Scala collections
and Java collections.
scala> class Person(val name: String, val age: Int) {
| override def toString = s"$name ($age)"
| }
defined class Person
scala> def underagePeopleNames(persons: List[Person]) = {
| for (person <- persons; if person.age < 18)
| yield person.name
| }
underagePeopleNames: (persons: List[Person])List[String]
scala> def createRandomPeople() = {
| val names = List("Alice", "Bob", "Carol",
| "Dave", "Eve", "Frank")
| for (name <- names) yield {
| val age = (Random.nextGaussian()*8 + 20).toInt
| new Person(name, age)
| }
| }
createRandomPeople: ()List[Person]
scala> val people = createRandomPeople()
people: List[Person] = List(Alice (16), Bob (16), Carol (19), Dave (18), Eve (26), Frank (11))
scala> underagePeopleNames(people)
res1: List[String] = List(Alice, Bob, Frank)Let the compiler figure out the types for you
The Scala compiler is smart about static types. Most of the time, you need not tell it the types of your variables. Instead, its powerful type inference will figure them out for you.
In this interactive REPL session (Read-Eval-Print-Loop), we define a class and two functions. You can observe that the compiler infers the result types of the functions automatically, as well as all the intermediate values.
val x = Future { someExpensiveComputation() }
val y = Future { someOtherExpensiveComputation() }
val z = for (a <- x; b <- y) yield a*b
for (c <- z) println("Result: " + c)
println("Meanwhile, the main thread goes on!")Go Concurrent or Distributed with Futures & Promises
In Scala, futures and promises can be used to process data asynchronously, making it easier to parallelize or even distribute your application.
In this example, the Future{} construct evaluates its argument asynchronously, and returns
a handle to the asynchronous result as a Future[Int].
For-comprehensions can be used to register new callbacks (to post new things to do) when the future is
completed, i.e., when the computation is finished.
And since all this is executed asynchronously, without blocking, the main
program thread can continue doing other work in the meantime.
Traits
Combine the flexibility of Java-style interfaces with the power of classes. Think principled multiple-inheritance.
Pattern Matching
Think “switch” on steroids. Match against class hierarchies, sequences, constants and more.
Higher-order functions
Functions are first-class objects. Compose them with guaranteed type safety. Use them anywhere, pass them to anything.
abstract class Spacecraft {
def engage(): Unit
}
trait CommandoBridge extends Spacecraft {
def engage(): Unit = {
for (_ <- 1 to 3)
speedUp()
}
def speedUp(): Unit
}
trait PulseEngine extends Spacecraft {
val maxPulse: Int
var currentPulse: Int = 0
def speedUp(): Unit = {
if (currentPulse < maxPulse)
currentPulse += 1
}
}
class StarCruiser extends Spacecraft
with CommandoBridge
with PulseEngine {
val maxPulse = 200
}Flexibly Combine Interface & Behavior
In Scala, multiple traits can be mixed into a class to combine their interface and their behavior.
Here, a StarCruiser is a Spacecraft with a CommandoBridge that knows how to
engage the ship (provided a means to speed up) and a PulseEngine that
specifies how to speed up.
Switch on the structure of your data
In Scala, case classes are used to represent structural data
types. They implicitly equip the class with meaningful toString,
equals and hashCode methods, as well as the
ability to be deconstructed with pattern matching.
In this example, we define a small set of case classes that represent binary
trees of integers (the generic version is omitted for simplicity here).
In inOrder, the match construct chooses the right
branch, depending on the type of t, and at the same time
deconstructs the arguments of a Node.
// Define a set of case classes for representing binary trees.
sealed abstract class Tree
case class Node(elem: Int, left: Tree, right: Tree) extends Tree
case object Leaf extends Tree
// Return the in-order traversal sequence of a given tree.
def inOrder(t: Tree): List[Int] = t match {
case Node(e, l, r) => inOrder(l) ::: List(e) ::: inOrder(r)
case Leaf => List()
}Go Functional with Higher-Order Functions
In Scala, functions are values, and can be defined as anonymous functions with a concise syntax.
val people: Array[Person]
// Partition `people` into two arrays `minors` and `adults`.
// Use the anonymous function `(_.age < 18)` as a predicate for partitioning.
val (minors, adults) = people partition (_.age < 18)List<Person> people;
List<Person> minors = new ArrayList<Person>(people.size());
List<Person> adults = new ArrayList<Person>(people.size());
for (Person person : people) {
if (person.getAge() < 18)
minors.add(person);
else
adults.add(person);
}Ideal for teaching
Scala is ideal for teaching programming to beginners as well as for teaching advanced software engineering courses.
Readable and Versatile
Most of the concepts involved in software design directly map into Scala constructs. The concise syntax of Scala allows the teachers and the learners to focus on those interesting concepts without dealing with tedious low-level implementation issues.
The example in file HelloWorld.scala below shows how a “hello
world” program looks like in Scala. In Modeling.scala, we show an
example of structuring the information of a problem domain in Scala. In
Modules.scala, we show how straightforward it is to implement software modules with Scala classes. Last, in Algorithms.scala, we show how the
standard Scala collections can be leveraged to implement algorithms with
few lines of code.
Learn more in the dedicated page about Teaching.
@main def run() = println("Hello, World!")// A module that can access the data stored in a database
class DatabaseAccess(connection: Connection):
def readData(): Seq[Data] = ???
// An HTTP server, which uses the `DatabaseAccess` module
class HttpServer(databaseAccess: DatabaseAccess):
// The HTTP server can call `readData`, but it cannot
// access the underlying database connection, which is
// an implementation detail
databaseAccess.readData()/** A Player can either be a Bot, or a Human.
* In case it is a Human, it has a name.
*/
enum Player:
case Bot
case Human(name: String)// Average number of contacts a person has according to age
def contactsByAge(people: Seq[Person]): Map[Int, Double] =
people
.groupMap(
person => person.age
)(
person => person.contacts.size
)
.map((age, contactCounts) =>
val averageContactCount =
contactCounts.sum.toDouble / contactCounts.size
(age, averageContactCount)
)Scala runs on the following platforms...
Scala's libraries unlock your potential
Big Data Processing
Machine Learning
Notebooks
Streaming Services
Full Stack Web Design
Serverless
Finance
Use The File System
Text Processing
Scala is widely used in all these areas and more.
Looking for upcoming events?
Or want to chat with like-minded users? Visit the Community page to learn more.
The Scala language is maintained by
The Scala Center is supported by
