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
|
trait
|
Application
extends AnyRef
The object Main extends Application { Console.println("Hello World!") }
Here, object
It is possible to time the execution of objects that inherit from class
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
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) } } |
trait
|
Function0
[+R] extends AnyRef
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()) } |
trait
|
Function1
[-T1, +R] extends AnyRef
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)) } |
trait
|
Function2
[-T1, -T2, +R] extends AnyRef
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)) } |
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 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 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
For instance, the Scala
term |
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.
Method body is not generated if method is marked with |
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
|
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. |