Scala 2.6.1-final
API Specification

This document is the API specification for Scala Library Documentation

Class Summary
`case final class` | :: [B](`private` hd : B, `val` tl : List[B])`extends` List[B]`with` Product A non empty list characterized by a head and a tail.
`sealed abstract class` | All$ `extends` AnyRef 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$ `extends` AnyRef 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 `extends` AnyRef 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`.
`trait` | Application `extends` AnyRef 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
`final class` | Array [A](_length : Int)`extends` Array0[A] This class represents polymorphic arrays. `Array[T]` is Scala's representation for Java's `T[]`.
`abstract class` | Attribute `extends` AnyRef
`class` | BigInt (`val` bigInteger : java.math.BigInteger)`extends` java.lang.Number `with` AnyRef
`trait` | BufferedIterator [+A]`extends` Iterator[A] Buffered iterators are iterators which allow to inspect the next element without discarding it.
`trait` | ByNameFunction [-A, +B]`extends` AnyRef 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.
`case class` | Cell [+T](`val` elem : T)`extends` Product 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.
`trait` | ClassfileAnnotation `extends` Annotation A base class for classfile annotations. These are stored as Java annotations in classfiles.
`trait` | ClassfileAttribute `extends` Attribute A base class for classfile attributes. These are stored as Java annotations in classfiles.
`trait` | Collection [+A]`extends` Iterable[A] Variant of `Iterable` used to describe collections with a finite number of elements. Basically, this trait just adds size and toString to Iterable, as most of the methods in Iterable already assume finite-ness.
`trait` | CollectionProxy [+A]`extends` Collection[A]`with` IterableProxy[A] This class implements a proxy for iterable objects. It forwards all calls to a different iterable object.
`trait` | CountedIterator [+A]`extends` Iterator[A] Counted iterators keep track of the number of elements seen so far
`abstract class` | Enumeration (initial : Int, names : java.lang.String*)`extends` AnyRef 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) }
      }
`trait` | Function0 [+R]`extends` AnyRef 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())
      }
`trait` | Function1 [-T1, +R]`extends` AnyRef 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))
      }
`trait` | Function2 [-T1, -T2, +R]`extends` AnyRef 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))
      }
`trait` | Function3 [-T1, -T2, -T3, +R]`extends` AnyRef Function with 3 parameters.
`trait` | Function4 [-T1, -T2, -T3, -T4, +R]`extends` AnyRef Function with 4 parameters.
`trait` | Function5 [-T1, -T2, -T3, -T4, -T5, +R]`extends` AnyRef Function with 5 parameters.
`trait` | Function6 [-T1, -T2, -T3, -T4, -T5, -T6, +R]`extends` AnyRef Function with 6 parameters.
`trait` | Function7 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R]`extends` AnyRef Function with 7 parameters.
`trait` | Function8 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R]`extends` AnyRef Function with 8 parameters.
`trait` | Function9 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R]`extends` AnyRef Function with 9 parameters
`trait` | Iterable [+A]`extends` AnyRef Collection classes mixing in this class provide a method `elements` which returns an iterator over all the elements contained in the collection.
`trait` | IterableProxy [+A]`extends` Iterable[A]`with` Proxy This class implements a proxy for iterable objects. It forwards all calls to a different iterable object.
`trait` | Iterator [+A]`extends` AnyRef 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.
`sealed abstract class` | List [+A]`extends` Seq[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 (msg : java.lang.String)`extends` java.lang.RuntimeException `with` AnyRef This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.
`final class` | NotDefinedError (msg : java.lang.String)`extends` java.lang.Error `with` AnyRef
`trait` | NotNull `extends` AnyRef A marker thread for things that are not allowed to be null
`sealed abstract class` | Option [+A]`extends` Product This class represents optional values. Instances of `Option` are either instances of case class `Some` or it is case object `None`.
`trait` | Ordered [A]`extends` AnyRef A class for totally ordered data. Note that since version 2006-07-24 this class is no longer covariant in a.
`trait` | PartialFunction [-A, +B]`extends` (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.
`trait` | PartiallyOrdered [+A]`extends` AnyRef A class for partially ordered data.
`trait` | Product `extends` AnyRef The trait `Product` defines access functions for instances of products, in particular case classes.
`trait` | Product1 [+T1]`extends` Product Product1 is a cartesian product of 1 components
`trait` | Product10 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10]`extends` Product Product10 is a cartesian product of 10 components
`trait` | Product11 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11]`extends` Product Product11 is a cartesian product of 11 components
`trait` | Product12 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12]`extends` Product Product12 is a cartesian product of 12 components
`trait` | Product13 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13]`extends` Product Product13 is a cartesian product of 13 components
`trait` | Product14 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14]`extends` Product Product14 is a cartesian product of 14 components
`trait` | Product15 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15]`extends` Product Product15 is a cartesian product of 15 components
`trait` | Product16 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16]`extends` Product Product16 is a cartesian product of 16 components
`trait` | Product17 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17]`extends` Product Product17 is a cartesian product of 17 components
`trait` | Product18 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18]`extends` Product Product18 is a cartesian product of 18 components
`trait` | Product19 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19]`extends` Product Product19 is a cartesian product of 19 components
`trait` | Product2 [+T1, +T2]`extends` Product Product2 is a cartesian product of 2 components
`trait` | Product20 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20]`extends` Product Product20 is a cartesian product of 20 components
`trait` | Product21 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21]`extends` Product Product21 is a cartesian product of 21 components
`trait` | Product22 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22]`extends` Product Product22 is a cartesian product of 22 components
`trait` | Product3 [+T1, +T2, +T3]`extends` Product Product3 is a cartesian product of 3 components
`trait` | Product4 [+T1, +T2, +T3, +T4]`extends` Product Product4 is a cartesian product of 4 components
`trait` | Product5 [+T1, +T2, +T3, +T4, +T5]`extends` Product Product5 is a cartesian product of 5 components
`trait` | Product6 [+T1, +T2, +T3, +T4, +T5, +T6]`extends` Product Product6 is a cartesian product of 6 components
`trait` | Product7 [+T1, +T2, +T3, +T4, +T5, +T6, +T7]`extends` Product Product7 is a cartesian product of 7 components
`trait` | Product8 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8]`extends` Product Product8 is a cartesian product of 8 components
`trait` | Product9 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9]`extends` Product Product9 is a cartesian product of 9 components
`trait` | Proxy `extends` AnyRef 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.
`class` | Random (`val` self : java.util.Random)`extends` AnyRef
`trait` | RandomAccessSeq [+A]`extends` Seq[A] Sequences that support O(1) element access and O(1) length computation.
`class` | Range (`val` start : Int, `val` end : Int, `val` step : Int)`extends` Projection[Int] The `Range` class represents integer values in range `[start;end)` with non-zero step value `step`. Sort of acts like a sequence also (supports length and contains). For example:
         val r1 = Iterator.range(0, 10)
         val r2 = Iterator.range(r1.start, r1.end, r1.step + 1)
         println(r2.length) // = 5
`abstract class` | Responder [+A]`extends` AnyRef 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.
`trait` | AnyRef `extends` AnyRef
`trait` | Seq [+A]`extends` PartialFunction[Int, A]`with` Collection[A] Class `Seq[A]` represents finite sequences of elements of type `A`.
`trait` | SeqProxy [+A]`extends` Seq[A]`with` IterableProxy[A] This class implements a proxy for sequences. It forwards all calls to a different sequence object.
`class` | SerialVersionUID (uid : Long)`extends` Annotation Annotation for specifying the static SerialVersionUID field of a serializable class
`case final class` | Some [+A](`val` x : A)`extends` Option[A] Class `Some[A]` represents existing values of type `A`.
`trait` | StaticAnnotation `extends` Annotation A base class for static annotations. These are available to the Scala type checker, even across different compilation units.
`trait` | StaticAttribute `extends` Attribute A base class for static attributes. These are available to the Scala type checker, even across different compilation units.
`trait` | Stream [+A]`extends` Projection[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 { _ % s.head != 0 }))

       def primes = sieve(from(2))

       primes take 10 print
     }
`case final class` | Symbol (`val` name : java.lang.String)`extends` Product 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](`val` _1 : T1)`extends` Product1[T1] Tuple1 is the canonical representation of a @see Product1
`case class` | Tuple10 [+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10)`extends` Product10[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11)`extends` Product11[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12)`extends` Product12[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13)`extends` Product13[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14)`extends` Product14[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15)`extends` Product15[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16)`extends` Product16[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16, `val` _17 : T17)`extends` Product17[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16, `val` _17 : T17, `val` _18 : T18)`extends` Product18[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16, `val` _17 : T17, `val` _18 : T18, `val` _19 : T19)`extends` Product19[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](`val` _1 : T1, `val` _2 : T2)`extends` Product2[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16, `val` _17 : T17, `val` _18 : T18, `val` _19 : T19, `val` _20 : T20)`extends` Product20[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16, `val` _17 : T17, `val` _18 : T18, `val` _19 : T19, `val` _20 : T20, `val` _21 : T21)`extends` Product21[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9, `val` _10 : T10, `val` _11 : T11, `val` _12 : T12, `val` _13 : T13, `val` _14 : T14, `val` _15 : T15, `val` _16 : T16, `val` _17 : T17, `val` _18 : T18, `val` _19 : T19, `val` _20 : T20, `val` _21 : T21, `val` _22 : T22)`extends` Product22[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3)`extends` Product3[T1, T2, T3] Tuple3 is the canonical representation of a @see Product3
`case class` | Tuple4 [+T1, +T2, +T3, +T4](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4)`extends` Product4[T1, T2, T3, T4] Tuple4 is the canonical representation of a @see Product4
`case class` | Tuple5 [+T1, +T2, +T3, +T4, +T5](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5)`extends` Product5[T1, T2, T3, T4, T5] Tuple5 is the canonical representation of a @see Product5
`case class` | Tuple6 [+T1, +T2, +T3, +T4, +T5, +T6](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6)`extends` Product6[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7)`extends` Product7[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8)`extends` Product8[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](`val` _1 : T1, `val` _2 : T2, `val` _3 : T3, `val` _4 : T4, `val` _5 : T5, `val` _6 : T6, `val` _7 : T7, `val` _8 : T8, `val` _9 : T9)`extends` Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9] Tuple9 is the canonical representation of a @see Product9
`trait` | TypeConstraint `extends` Annotation A marker for annotations that, when applied to a type, should be treated as a constraint on the annotated type. A proper constraint should restrict the type based only on information mentioned within the type. A Scala compiler can use this assumption to rewrite the contents of the constraint as necessary. To contrast, a type annotation whose meaning depends on the context where it is written down is not a proper constrained type, and this marker should not be applied. A Scala compiler will drop such annotations in cases where it would rewrite a type constraint.
`final class` | UninitializedError `extends` java.lang.RuntimeException `with` AnyRef This class represents uninitialized variable/value errors.
`class` | cloneable `extends` Annotation An annotation that designates the class to which it is applied as cloneable
`class` | deprecated `extends` StaticAnnotation An annotation that designates the definition to which it is applied as deprecated. Access to the member then generates a deprecated warning.
`class` | inline `extends` StaticAnnotation An annotation on methods that requests that the compiler should try especially hard to inline the annotated method.
`class` | native `extends` Annotation Marker for native methods. `@native def f(x: Int, y: List[Long]): String = ..` Method body is not generated if method is marked with `@native`, but it is type checked when present.
`class` | noinline `extends` StaticAnnotation An annotation on methods that forbids the compiler to inline the method, no matter how safe the inlining appears to be.
`class` | remote `extends` Annotation An annotation that designates the class to which it is applied as remotable.
`class` | serializable `extends` Annotation An annotation that designates the class to which it is applied as serializable
`class` | throws (clazz : java.lang.Class)`extends` Annotation 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 `extends` Annotation
`class` | unchecked `extends` Annotation 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 `extends` Annotation
`class` | volatile `extends` Annotation

Object Summary
`object` | Array `extends` AnyRef This object contains utility methods operating on arrays.
`object` | BigInt `extends` AnyRef
`object` | BufferedIterator `extends` AnyRef
`object` | Console `extends` AnyRef 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 `extends` AnyRef A module defining utility methods for higher-order functional programming.
`object` | Iterable `extends` AnyRef Various utilities for instances of Iterable.
`object` | Iterator `extends` AnyRef The `Iterator` object provides various functions for creating specialized iterators.
`object` | List `extends` AnyRef This object provides methods for creating specialized lists, and for transforming special kinds of lists (e.g. lists of lists).
`object` | Math `extends` AnyRef The object `Math` contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
`case object` | Nil `extends` List[Nothing]`with` Product The empty list.
`case object` | None `extends` Option[Nothing] This case object represents non-existent values.
`object` | Option `extends` AnyRef
`object` | Predef `extends` AnyRef The `Predef` object provides definitions that are accessible in all Scala compilation units without explicit qualification.
`object` | Product1 `extends` AnyRef
`object` | Product10 `extends` AnyRef
`object` | Product11 `extends` AnyRef
`object` | Product12 `extends` AnyRef
`object` | Product13 `extends` AnyRef
`object` | Product14 `extends` AnyRef
`object` | Product15 `extends` AnyRef
`object` | Product16 `extends` AnyRef
`object` | Product17 `extends` AnyRef
`object` | Product18 `extends` AnyRef
`object` | Product19 `extends` AnyRef
`object` | Product2 `extends` AnyRef
`object` | Product20 `extends` AnyRef
`object` | Product21 `extends` AnyRef
`object` | Product22 `extends` AnyRef
`object` | Product3 `extends` AnyRef
`object` | Product4 `extends` AnyRef
`object` | Product5 `extends` AnyRef
`object` | Product6 `extends` AnyRef
`object` | Product7 `extends` AnyRef
`object` | Product8 `extends` AnyRef
`object` | Product9 `extends` AnyRef
`object` | RandomAccessSeq `extends` AnyRef
`object` | Responder `extends` AnyRef This object contains utility methods to build responders.
`object` | Seq `extends` AnyRef
`object` | Stream `extends` AnyRef The object `Stream` provides helper functions to manipulate streams.