Scala 2

API Specification

This document is the API specification for Scala 2.

Class Summary
final case class :: [b]
A non empty list characterized by a head and a tail.
sealed abstract class All$
Dummy class which exist only to satisfy the JVM. It corresponds to scala.All. If such type appears in method signatures, it is erased to this one.
sealed abstract class AllRef$
Dummy class which exist only to satisfy the JVM. It corresponds to scala.AllRef. If such type appears in method signatures, it is erased to this one.
abstract class Annotation

A base class for annotations. Annotations extending this class directly are not preserved for the Scala type checker and are also not stored as Java annotations in classfiles. To enable either or both of these, one needs to inherit from StaticAnnotation or/and ClassfileAnnotation.


final class Array [A]
This class represents polymorphic arrays. It is never instantiated.
abstract class Attribute


class BigInt

case class Cell [+T]
A Cell is a generic wrapper which completely hides the functionality of the wrapped object. The wrapped object is accessible via the elem accessor method.
abstract class Enumeration

Defines a finite set of values specific to the enumeration. Typically these values enumerate all possible forms something can take and provide a lightweight alternative to case classes.

Each call to a Value method adds a new unique value to the enumeration. To be accessible, these values are usually defined as val members of the evaluation

All values in an enumeration share a common, unique type defined as the Value type member of the enumeration (Value selected on the stable identifier path of the enumeration instance).

Example use

  object Main extends Application {
 
    object WeekDays extends Enumeration  {
      val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
    }
 
    def isWorkingDay(d: WeekDays.Value) =
      ! (d == WeekDays.Sat || d == WeekDays.Sun)
  
    WeekDays filter (isWorkingDay) foreach { d => Console.println(d) }
  }

sealed abstract class List [+a]
A class representing an ordered collection of elements of type a. This class comes with two implementing case classes scala.Nil and scala.:: that implement the abstract members isEmpty, head and tail.
final class MatchError

final class NotDefinedError

sealed abstract class Option [+A]
This class represents optional values. Instances of Option are either instances of case class Some or it is case object None.
abstract class Responder [+a]
Instances of responder are the building blocks of small programs written in continuation passing style. By using responder classes in for comprehensions, one can embed domain-specific languages in Scala while giving the impression that programs in these DSLs are written in direct style.
class SerialVersionUID
Annotation for specifying the static SerialVersionUID field of a serializable class
final case class Some [+A]
Class Some[A] represents existing values of type A.
final case class Symbol

Instances of Symbol can be created easily with Scala's built-in quote mechanism.

For instance, the Scala term 'mysym will invoke the constructor of the Symbol class in the following way: new Symbol("mysym").


case class Tuple1 [+T1]
Tuple1 is the canonical representation of a @see Product1
case class Tuple10 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10]
Tuple10 is the canonical representation of a @see Product10
case class Tuple11 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11]
Tuple11 is the canonical representation of a @see Product11
case class Tuple12 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12]
Tuple12 is the canonical representation of a @see Product12
case class Tuple13 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13]
Tuple13 is the canonical representation of a @see Product13
case class Tuple14 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14]
Tuple14 is the canonical representation of a @see Product14
case class Tuple15 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15]
Tuple15 is the canonical representation of a @see Product15
case class Tuple16 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16]
Tuple16 is the canonical representation of a @see Product16
case class Tuple17 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17]
Tuple17 is the canonical representation of a @see Product17
case class Tuple18 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18]
Tuple18 is the canonical representation of a @see Product18
case class Tuple19 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19]
Tuple19 is the canonical representation of a @see Product19
case class Tuple2 [+T1, +T2]
Tuple2 is the canonical representation of a @see Product2
case class Tuple20 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20]
Tuple20 is the canonical representation of a @see Product20
case class Tuple21 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21]
Tuple21 is the canonical representation of a @see Product21
case class Tuple22 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22]
Tuple22 is the canonical representation of a @see Product22
case class Tuple3 [+T1, +T2, +T3]
Tuple3 is the canonical representation of a @see Product3
case class Tuple4 [+T1, +T2, +T3, +T4]
Tuple4 is the canonical representation of a @see Product4
case class Tuple5 [+T1, +T2, +T3, +T4, +T5]
Tuple5 is the canonical representation of a @see Product5
case class Tuple6 [+T1, +T2, +T3, +T4, +T5, +T6]
Tuple6 is the canonical representation of a @see Product6
case class Tuple7 [+T1, +T2, +T3, +T4, +T5, +T6, +T7]
Tuple7 is the canonical representation of a @see Product7
case class Tuple8 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8]
Tuple8 is the canonical representation of a @see Product8
case class Tuple9 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9]
Tuple9 is the canonical representation of a @see Product9
class cloneable
An annotation that designates the class to which it is applied as cloneable
class deprecated
An annotation that designates the definition to which it is applied as deprecated. Access to the member then generates a deprecated warning.
class remote
An annotation that designates the class to which it is applied as remotable.
class serializable
An annotation that designates the class to which it is applied as serializable
class throws

Annotation for specifying the exceptions thrown by a method. For example:

    class Reader(fname: String) {
      private val in =
        new BufferedReader(new FileReader(fname))
      @throws(classOf[IOException])
      def read() = in.read()
    }

class transient

class unchecked

An annotation that gets applied to a selector in a match expression. If it is present, exhaustiveness warnings for that expression will be suppressed.

For example, compiling the code:

    object test extends Application {
      def f(x: Option[int]) = x match {
        case Some(y) => y
      }
      f(None)
    }

will display the following warning:

    test.scala:2: warning: does not cover case {object None}
      def f(x: Option[int]) = x match {
                              ^
    one warning found

The above message may be suppressed by substituting the expression x with (x: @unchecked). Then the modified code will compile silently, but, in any case, a MatchError will be raised at runtime.


class unsealed

class volatile


Trait Summary
abstract trait Application
The Application class can be used to quickly turn objects into executable programs. Here is an example:
  object Main extends Application {
    Console.println("Hello World!")
  }
  
Here, object Main inherits the main method of Application. The body of the Main object defines the main program. This technique does not work if the main program depends on command-line arguments (which are not accessible with the technique presented here). It is possible to time the execution of objects that inherit from class Application by setting the global scala.time property. Here is an example for benchmarking object Main:
  java -Dscala.time Main
  

abstract trait BufferedIterator [+A]
Buffered iterators are iterators which allow to inspect the next element without discarding it.
abstract trait ByNameFunction [-A, +B]
A partial function of type PartialFunction[A, B] is a unary function where the domain does not include all values of type A. The function isDefinedAt allows to test dynamically, if a value is in the domain of the function.
abstract trait ClassfileAnnotation

A base class for classfile annotations. These are stored as Java annotations in classfiles.


abstract trait ClassfileAttribute

A base class for classfile attributes. These are stored as Java annotations in classfiles.


abstract trait CountedIterator [+A]
Counted iterators keep track of the number of elements seen so far
abstract trait Function0 [+R]

Function with 0 parameters.

In the following example the definition of currentSeconds is a shorthand for the anonymous class definition anonfun0:

  object Main extends Application {

    val currentSeconds = () => System.currentTimeMillis() / 1000L

    val anonfun0 = new Function0[Long] {
      def apply(): Long = System.currentTimeMillis() / 1000L
    }

    Console.println(currentSeconds())
    Console.println(anonfun0())
  }

abstract trait Function1 [-T1, +R]

Function with 1 parameters.

In the following example the definition of succ is a shorthand for the anonymous class definition anonfun1:

  object Main extends Application {

    val succ = (x: Int) => x + 1

    val anonfun1 = new Function1[Int, Int] {
      def apply(x: Int): Int = x + 1
    }

    Console.println(succ(0))
    Console.println(anonfun1(0))
  }

abstract trait Function2 [-T1, -T2, +R]

Function with 2 parameters.

In the following example the definition of max is a shorthand for the anonymous class definition anonfun2:

  object Main extends Application {

    val max = (x: Int, y: Int) => if (x < y) y else x

    val anonfun2 = new Function2[Int, Int, Int] {
      def apply(x: Int, y: Int): Int = if (x < y) y else x
    }

    Console.println(max(0, 1))
    Console.println(anonfun2(0, 1))
  }

abstract trait Function3 [-T1, -T2, -T3, +R]

Function with 3 parameters.


abstract trait Function4 [-T1, -T2, -T3, -T4, +R]

Function with 4 parameters.


abstract trait Function5 [-T1, -T2, -T3, -T4, -T5, +R]

Function with 5 parameters.


abstract trait Function6 [-T1, -T2, -T3, -T4, -T5, -T6, +R]

Function with 6 parameters.


abstract trait Function7 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R]

Function with 7 parameters.


abstract trait Function8 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R]

Function with 8 parameters.


abstract trait Function9 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R]
Function with 9 parameters
abstract trait Iterable [+A]
Collection classes mixing in this class provide a method elements which returns an iterator over all the elements contained in the collection.
abstract trait IterableProxy [+A]
This class implements a proxy for iterable objects. It forwards all calls to a different iterable object.
abstract trait Iterator [+A]
Iterators are data structures that allow to iterate over a sequence of elements. They have a hasNext method for checking if there is a next element available, and a next method which returns the next element and discards it from the iterator.
abstract trait Ordered [a]
A class for totally ordered data. Note that since version 2006-07-24 this class is no longer covariant in a.
abstract trait PartialFunction [-A, +B]
A partial function of type PartialFunction[A, B] is a unary function where the domain does not include all values of type A. The function isDefinedAt allows to test dynamically, if a value is in the domain of the function.
abstract trait PartiallyOrdered [+a]
A class for partially ordered data.
abstract trait Product
The trait Product defines access functions for instances of products, in particular case classes.
abstract trait Product1 [+T1]
Product1 is a cartesian product of 1 components
abstract trait Product10 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10]
Product10 is a cartesian product of 10 components
abstract trait Product11 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11]
Product11 is a cartesian product of 11 components
abstract trait Product12 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12]
Product12 is a cartesian product of 12 components
abstract trait Product13 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13]
Product13 is a cartesian product of 13 components
abstract trait Product14 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14]
Product14 is a cartesian product of 14 components
abstract trait Product15 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15]
Product15 is a cartesian product of 15 components
abstract trait Product16 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16]
Product16 is a cartesian product of 16 components
abstract trait Product17 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17]
Product17 is a cartesian product of 17 components
abstract trait Product18 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18]
Product18 is a cartesian product of 18 components
abstract trait Product19 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19]
Product19 is a cartesian product of 19 components
abstract trait Product2 [+T1, +T2]
Product2 is a cartesian product of 2 components
abstract trait Product20 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20]
Product20 is a cartesian product of 20 components
abstract trait Product21 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21]
Product21 is a cartesian product of 21 components
abstract trait Product22 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22]
Product22 is a cartesian product of 22 components
abstract trait Product3 [+T1, +T2, +T3]
Product3 is a cartesian product of 3 components
abstract trait Product4 [+T1, +T2, +T3, +T4]
Product4 is a cartesian product of 4 components
abstract trait Product5 [+T1, +T2, +T3, +T4, +T5]
Product5 is a cartesian product of 5 components
abstract trait Product6 [+T1, +T2, +T3, +T4, +T5, +T6]
Product6 is a cartesian product of 6 components
abstract trait Product7 [+T1, +T2, +T3, +T4, +T5, +T6, +T7]
Product7 is a cartesian product of 7 components
abstract trait Product8 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8]
Product8 is a cartesian product of 8 components
abstract trait Product9 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9]
Product9 is a cartesian product of 9 components
abstract trait Proxy
This class implements a simple proxy that forwards all calls to methods of class Any to another object self. Please note that only those methods can be forwarded that are overridable and public.
abstract trait ScalaObject

abstract trait Seq [+A]
Class Seq[A] represents finite sequences of elements of type A.
abstract trait SeqProxy [+A]
This class implements a proxy for sequences. It forwards all calls to a different sequence object.
abstract trait StaticAnnotation

A base class for static annotations. These are available to the Scala type checker, even across different compilation units.


abstract trait StaticAttribute

A base class for static attributes. These are available to the Scala type checker, even across different compilation units.


abstract trait Stream [+a]

The class Stream implements lazy lists where elements are only evaluated when they are needed. Here is an example:

 object Main extends Application {

   def from(n: Int): Stream[Int] =
     Stream.cons(n, from(n + 1))

   def sieve(s: Stream[Int]): Stream[Int] =
     Stream.cons(s.head, sieve(s.tail filter { x => x % s.head != 0 }))

   def primes = sieve(from(2))

   primes take 10 print
 }
 


Object Summary
object Array
This object ...
object BigInt

object Console
The Console object implements functionality for printing Scala values on the terminal. There are also functions for reading specific values. Console also defines constants for marking up text on ANSI terminals.
object Function
A module defining utility methods for higher-order functional programming.
object Iterable
This object ...
object Iterator
The Iterator object provides various functions for creating specialized iterators.
object List
This object provides methods for creating specialized lists, and for transforming special kinds of lists (e.g. lists of lists).
object MatchError
This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.
object Math
The object Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
case object Nil
The empty list.
case object None
This case object represents non-existent values.
object Option

object Predef
The Predef object provides definitions that are accessible in all Scala compilation units without explicit qualification.
object Product1

object Product10

object Product11

object Product12

object Product13

object Product14

object Product15

object Product16

object Product17

object Product18

object Product19

object Product2

object Product20

object Product21

object Product22

object Product3

object Product4

object Product5

object Product6

object Product7

object Product8

object Product9

object Responder
This object contains utility methods to build responders.
object Seq

object Stream
The object Stream provides helper functions to manipulate streams.
object internedSymbols