Object-Oriented Meets Functional

Have the best of both worlds. Construct elegant class hierarchies for maximum code reuse and extensibility, implement their behavior using higher-order functions. Or anything in-between.

Learn More

 

Scala began life in 2003, created by Martin Odersky and his research group at EPFL, next to Lake Geneva and the Alps, in Lausanne, Switzerland. Scala has since grown into a mature open source programming language, used by hundreds of thousands of developers, and is developed and maintained by scores of people all over the world.
Download API Docs    
Spiral
Scala
2.12.0

Getting Started

gears icon Milestones, nightlies, etc.

list icon All Previous Releases

Current API Docs

list icon API Docs (other versions)

books icon Scala Documentation

books icon Language Specification

Scala in a Nutshell

 click the boxes below to see Scala in action! 

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.

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, and more.

Higher-Order Functions

Functions are first-class objects. Compose them with guaranteed type safety. Use them anywhere, pass them to anything.

Learn More

or visit the Scala Documentation

Author.scala
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] = ???
}
App.java
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.

Type inference
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.

Concurrent/Distributed
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
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.

Pattern matching
// 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()
}

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.

Go Functional with Higher-Order Functions

In Scala, functions are values, and can be defined as anonymous functions with a concise syntax.

Scala
val people: Array[Person]

// Partition `people` into two arrays `minors` and `adults`.
// Use the higher-order function `(_.age < 18)` as a predicate for partitioning.
val (minors, adults) = people partition (_.age < 18)
Java
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);
}

In the Scala example on the left, the partition method, available on all collection types (including Array), returns two new collections of the same type. Elements from the original collection are partitioned according to a predicate, which is given as a lambda, i.e., an anonymous function. The _ stands for the parameter to the lambda, i.e., the element that is being tested. This particular lambda can also be written as (x => x.age < 18).

The same program is implemented in Java on the right.

Upcoming Events

See more events or add one to our feed

Upcoming Training

What's New

blog
SPLASH Amsterdam and Higher-kinded Types
date icon Thursday, November 17, 2016

Two weeks ago I was in Amsterdam, where we had the Scala Symposium as part of the SPLASH conference. I gave a talk at the symposium and then later on a keynote at the main conference. I had a great time, staying in a hotel on one of Amsterdam’s lovely canals and commuting by bike to the conference center. Amsterdam is a fantastic city for biking. Each day I picked another route along a different canal, and the route generally could not be long enough for me (I missed a couple of talks because of that). I noted that it’s important to always stick to the traffic rules, for instance to give way to traffic coming from the right, or you would get into an accident between two bicycles; there are so many of them around.

SPLASH is a set of conferences running together (OOPSLA being one of the main ones), so you get exposed to a variety of topics and get to talk to people from many different areas. One talk that stood out for me was Simon Peyton Jones speaking about how they are reforming the UK curriculum to teach computational thinking to kids from primary school on. It’s been Simon’s main “other” occupation besides Haskell and he gave a fascinating talk that conveyed his great enthusiasm for the cause of teaching computing the right way to every kid. His message was that we have to act now, when things are waiting to be defined. A quote: “We know we have failed if, 10 years from now, the outcome is just that every kid can code Java”.

At the Scala Symposium I spoke about how we implemented higher-kinded types in Dotty. This was a long and often painful journey. In total we tried four different approaches. Each of them was an effort of many weeks – sometimes several months – to implement the new scheme, debug it, and then finally discard it because we found out it was too hard to get right, or did not otherwise live up to expectations.

The original reason for trying so many different avenues had to do with DOT, which is intended to be the foundation of future Scala. DOT as-is has no provision for higher-kinded types, but it turns out that a restricted version of higher-kinded types can be straightforwardly encoded in it. That issue is not just academic because the dotty compiler uses DOT’s constructs as its core data structures. So what is hard to do in DOT tends to be hard to implement in the compiler as well.

Originally, we played with the idea to restrict higher-kinded types to just the kind of partial applications that can be conveniently encoded in DOT or dotty. The main problem was that this would have forced us to restrict the Scala language. More advanced idioms, such as type classes for Monad and Functor would have required rewrites and would not be as convenient to use. The boundary between what was expressible and what was illegal was also not very intuitive. For instance, one could define an abstract polymorphic subtype of Maps in the usual way:

type M[K, V] <: Map[K, V]

But one could not define a type where the parameters were reversed. I.e.

type M[V, K] <: Map[K, V]

would have been illegal.

To address these limitations, we then played with two more complicated encodings of higher-kinded types in dotty’s core types. Neither of these worked out very well so in the end we settled for the “brute force” approach of adding higher-kinded types without trying to re-use most of the core. All these attempts are described in the paper Implementing Higher-Kinded Types in Dotty. The talk was not recorded but I have uploaded the slides.

Another interesting development was that after the talk I got together with Sandro Stucki and Guillaume Martres and we hashed out a slight extension of DOT, which would make it much more convenient for more advanced dependent type programming and, as a side effect, would make it quite suitable to express higher-kinded types as well. If this works out it would be a case where compiler hacking influenced the way we do theory. It’s usually more efficient to do theory first and implement it systematically once it’s done, but sometimes going from practice to theory is the only route available.

more...

Recently...

Scala 2.12.0 is now available!
date-icon Thursday, November 03, 2016 announcement
We are very happy to announce the availability of Scala 2.12.0! Headline features The Scala 2.12 compiler has been completely overhauled to make use of...
Scala 2.12.0
date-icon Thursday, November 03, 2016
Erik Osheim receives community award
date-icon Wednesday, October 26, 2016 news
We are pleased to announce that the Phil Bagwell Memorial Scala Community Award for 2016 has been awarded to Erik Osheim. The award was presented...
date-icon
For more, visit our
News archive or Blog

Scala on Twitter


 
See more tweets, or
Follow Scala on Twitter
white Twitter logo
EPFL logo


Copyright © 2002- École Polytechnique Fédérale de Lausanne (EPFL)
Lausanne, Switzerland

Scala footer logo