This class represents polymorphic arrays. Array[T] is Scala's representation for Java's 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.

Counted iterators keep track of the number of elements seen so far

A trait for representing equivalence relations. It is important to distinguish between a type that can be compared for equality or equivalence and a representation of equivalence on some type. This trait is for representing the latter. An equivalence relation is a binary relation on a type. This relation is exposed as the equiv method of the Equiv trait. This relation must be:

• reflexive: equiv(x, x) == true, for any x of type T.
• symmetric: equiv(x, y) == equiv(y, x), for any x and y of type T.
• transitive: if equiv(x, y) == true and equiv(y, z) == true then equiv(x, z) == true, for any x, y, and z of type T.

A marker trait for all immutable datastructures such as imutable collections

The left side of the disjoint union, as opposed to the Right side.

This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.

A marker trait for mutable datatructures such as mutable collections

A marker trait for things that are not allowed to be null

This class represents optional values. Instances of Option are either instances of case class Some or it is case object None.

A trait for totally ordered data. Note that since version 2006-07-24 this trait is no longer covariant in a. It is important that the equals method for an instance of Ordered[A] be consistent with the compare method. However, due to limitations inherent in the type erasure semantics, there is no reasonable way to provide a default implementation of equality for instances of Ordered[A]. Therefore, if you need to be able to use equality on an instance of Ordered[A] you must provide it yourself either when inheiriting or instantiating. It is important that the hashCode method for an instance of Ordered[A] be consistent with the compare method. However, it is not possible to provide a sensible default implementation. Therefore, if you need to be able compute the hash of an instance of Ordered[A] you must provide it yourself either when inheiriting or instantiating.

A trait for representing total orderings. It is important to distinguish between a type that has a total order and a representation of total ordering on some type. This trait is for representing the latter. A total ordering is a binary relation on a type T that is also an equivalence relation and partial ordering on values of type T. This relation is exposed as the compare method of the Ordering trait. This relation must be:

• reflexive: compare(x, x) == 0, for any x of type T.
• symmetry: compare(x, y) == z and compare(y, x) == w then Math.signum(z) == -Math.signum(w), for any x and y of type T and z and w of type Int.
• transitive: if compare(x, y) == z and compare(y, w) == v and Math.signum(z) >= 0 and Math.signum(v) >= 0 then compare(x, w) == u and Math.signum(z + v) == Math.signum(u), for any x, y, and w of type T and z, v, and u of type Int.

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.

A trait for representing partial orderings. It is important to distinguish between a type that has a partial order and a representation of partial ordering on some type. This trait is for representing the latter. A partial ordering is a binary relation on a type T that is also an equivalence relation on values of type T. This relation is exposed as the lteq method of the PartialOrdering trait. This relation must be:

• reflexive: lteq(x, x) == true, for any x of type T.
• anti-symmetric: lteq(x, y) == true and lteq(y, x) == true then equiv(x, y), for any x and y of type T.
• transitive: if lteq(x, y) == true and lteq(y, z) == true then lteq(x, z) == true, for any x, y, and z of type T.

A class for partially ordered data.

The trait Product defines access functions for instances of products, in particular case classes.

Product1 is a cartesian product of 1 component.

Product10 is a cartesian product of 10 components.

Product11 is a cartesian product of 11 components.

Product12 is a cartesian product of 12 components.

Product13 is a cartesian product of 13 components.

Product14 is a cartesian product of 14 components.

Product15 is a cartesian product of 15 components.

Product16 is a cartesian product of 16 components.

Product17 is a cartesian product of 17 components.

Product18 is a cartesian product of 18 components.

Product19 is a cartesian product of 19 components.

Product2 is a cartesian product of 2 components.

Product20 is a cartesian product of 20 components.

Product21 is a cartesian product of 21 components.

Product22 is a cartesian product of 22 components.

Product3 is a cartesian product of 3 components.

Product4 is a cartesian product of 4 components.

Product5 is a cartesian product of 5 components.

Product6 is a cartesian product of 6 components.

Product7 is a cartesian product of 7 components.

Product8 is a cartesian product of 8 components.

Product9 is a cartesian product of 9 components.

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.

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.

The right side of the disjoint union, as opposed to the Left side.

Annotation for specifying the static SerialVersionUID field of a serializable class

Class Some[A] represents existing values of type A.

Tuple1 is the canonical representation of a @see Product1

Tuple10 is the canonical representation of a @see Product10

Tuple11 is the canonical representation of a @see Product11

Tuple12 is the canonical representation of a @see Product12

Tuple13 is the canonical representation of a @see Product13

Tuple14 is the canonical representation of a @see Product14

Tuple15 is the canonical representation of a @see Product15

Tuple16 is the canonical representation of a @see Product16

Tuple17 is the canonical representation of a @see Product17

Tuple18 is the canonical representation of a @see Product18

Tuple19 is the canonical representation of a @see Product19

Tuple2 is the canonical representation of a @see Product2

Tuple20 is the canonical representation of a @see Product20

Tuple21 is the canonical representation of a @see Product21

Tuple22 is the canonical representation of a @see Product22

Tuple3 is the canonical representation of a @see Product3

Tuple4 is the canonical representation of a @see Product4

Tuple5 is the canonical representation of a @see Product5

Tuple6 is the canonical representation of a @see Product6

Tuple7 is the canonical representation of a @see Product7

Tuple8 is the canonical representation of a @see Product8

Tuple9 is the canonical representation of a @see Product9

This class represents uninitialized variable/value errors.

This class implements errors which are thrown whenever a field is used before it has been initialized. Such runtime checks are not emitted by default. See the compiler documentation for knowing how to turn them on. Note: This check requires the new initialization order, planned for 2.8.0 and available under -Xexperimental.

An annotation that designates the class to which it is applied as cloneable

An annotation that designates the definition to which it is applied as deprecated. Access to the member then generates a deprecated warning.

An annotation on methods that requests that the compiler should try especially hard to inline the annotated method.

Marker for native methods.

An annotation on methods that forbids the compiler to inline the method, no matter how safe the inlining appears to be.

An annotation that designates the class to which it is applied as remotable.

An annotation that designates the class to which it is applied as serializable

Annotate type parameters on which code should be automatically specialized. For example: class MyList[@specialized T] ... Type T can be specialized on a subset of the primitive types by specifying a comma-separated string argument: class MyList[@specialized("Int, Double, Boolean") T] .. Only primitive types are supported and no name resolution is currently done on the string arguments (meaning imports and type aliases are not resolved).

This object contains utility methods operating on arrays.

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.

A module defining utility methods for higher-order functional programming.

The object Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.

This case object represents non-existent values.

The Predef object provides definitions that are accessible in all Scala compilation units without explicit qualification.

This object contains utility methods to build responders.