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. |
mixin abstract
|
class
Application
The Application class can be used to quickly turn objects
into executable programs. Here is an example:
object Main with 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 ]
|
class
Attribute
A base class for attributes |
|
class
BigInt
|
|
mixin abstract
|
class
BufferedIterator
[ A ]
Buffered iterators are iterators which llow to inspect the next element without discarding it. |
mixin abstract
|
class
CaseClass
defines an access function for instances of case classes |
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.
|
mixin abstract
|
class
CountedIterator
[ A ]
Counted iterators keep track of the number of elements seen so far |
abstract
|
class
Enumeration
The class object Main with 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 => System.out.println(d) } } |
mixin abstract
|
class
Function0
[ R ]
Function with no parameters |
mixin abstract
|
class
Function1
[ T0 , R ]
Function with 1 parameter |
mixin abstract
|
class
Function2
[ T0 , T1 , R ]
Function with 2 parameters |
mixin abstract
|
class
Function3
[ T0 , T1 , T2 , R ]
Function with 3 parameters |
mixin abstract
|
class
Function4
[ T0 , T1 , T2 , T3 , R ]
Function with 4 parameters |
mixin abstract
|
class
Function5
[ T0 , T1 , T2 , T3 , T4 , R ]
Function with 5 parameters |
mixin abstract
|
class
Function6
[ T0 , T1 , T2 , T3 , T4 , T5 , R ]
Function with 6 parameters |
mixin abstract
|
class
Function7
[ T0 , T1 , T2 , T3 , T4 , T5 , T6 , R ]
Function with 7 parameters |
mixin abstract
|
class
Function8
[ T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , R ]
Function with 8 parameters |
mixin abstract
|
class
Function9
[ T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , R ]
Function with 9 parameters |
mixin abstract
|
class
Iterable
[ A ]
Collection classes mixing in this class provide a method elements which returns an iterator over all the
elements contained in the collection.
|
mixin abstract
|
class
IterableProxy
[ A ]
This class implements a proxy for iterable objects. It forwards all calls to a different iterable object. |
mixin abstract
|
class
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.
|
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 .
|
mixin abstract
|
class
Ordered
[ a ]
A class for totally ordered data. bq: Note that since version 2006-07-24, this class is no longer covariant in a. |
mixin abstract
|
class
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.
|
mixin abstract
|
class
PartiallyOrdered
[ a ]
A class for partially ordered data. |
mixin abstract
|
class
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
|
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. |
mixin abstract
|
class
ScalaObject
|
mixin abstract
|
class
Seq
[ A ]
Class Seq[A] represents finite sequences of elements
of type A .
|
mixin abstract
|
class
SeqProxy
[ A ]
Class Seq[A] represents finite sequences of elements
of type A .
|
class
SerialVersionUID
Attribute for specifying the static SerialVersionUID field of a serializable class |
|
final case
|
class
Some
[ A ]
Class Some[A] represents existing values of type
A .
|
mixin abstract
|
class
Stream
[ a ]
The class object Main with 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 } |
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 ]
|
case
|
class
Tuple2
[ T1 , T2 ]
|
case
|
class
Tuple3
[ T1 , T2 , T3 ]
|
case
|
class
Tuple4
[ T1 , T2 , T3 , T4 ]
|
case
|
class
Tuple5
[ T1 , T2 , T3 , T4 , T5 ]
|
case
|
class
Tuple6
[ T1 , T2 , T3 , T4 , T5 , T6 ]
|
case
|
class
Tuple7
[ T1 , T2 , T3 , T4 , T5 , T6 , T7 ]
|
case
|
class
Tuple8
[ T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ]
|
case
|
class
Tuple9
[ T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ]
|
class
_mixin_
Temporary class. When this appears in the attribute list of an abstract class, the class is assumed to be a mixin. Used to ensure that code that compiles under (old) scalac can also compile under nsc .
|
|
class
_trait_
Temporary class. When this appears in the attribute list of an abstract class, the class is assumed to be a trait. Used to ensure that code that compiles under (old) scalac can also compile under nsc .
|
|
class
cloneable
An attribute that designates the class to which it is applied as cloneable |
|
class
remote
|
|
class
serializable
An attribute that designates the class to which it is applied as serializable |
|
class
throws
Attribute for specifying the exceptions thrown by a method. |
|
class
transient
|
|
class
volatile
|
Object Summary | |
object
Array
|
|
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
Iterable
|
|
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. |
|
case
|
object
Nil
The empty list. |
case
|
object
None
This case object represents non-existent values. |
object
Predef
The Predef object provides definitions that are
accessible in all Scala compilation units without explicit
qualification.
|
|
object
Responder
contains utility methods to build responders |
|
object
Seq
|
|
object
Stream
The object Stream provides helper functions
to manipulate streams.
|