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 A base class for attributes. Atributes 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 `StaticAttribute` or/and `ClassfileAttribute`.
| `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 The class `Enumeration` provides the same functionality as the `enum` construct found in C-like languages like C++ or Java. Here is an example:
     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. Example:
     class Reader(fname: String) {
       private val in =
         new BufferedReader(new FileReader(fname))
       [throws(classOf[IOException])]
       def read() = in.read()
     }
| `class` transient
| `class` unsealed An annotation that gets applied to a selector in a match expression. If it is present, exhaustiveness warnings for that expression will be suppressed.
| `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