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
|
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 All values in an enumeration share a common, unique type defined as the
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
For instance, the Scala
term |
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
|
|
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
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
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
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 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
|