A non empty list characterized by a head and a tail.

This class represents polymorphic arrays. Array[T] is Scala's representation for Java's T[].

Buffered iterators are iterators which allow to inspect the next element without discarding it.

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 Cell is a generic wrapper which completely hides the functionality of the wrapped object. The wrapped object is accessible via the elem accessor method.

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.

This class implements a proxy for iterable objects. It forwards all calls to a different iterable object.

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.

Collection classes mixing in this class provide a method elements which returns an iterator over all the elements contained in the collection.

This class implements a proxy for iterable objects. It forwards all calls to a different iterable object.

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.

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

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.

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

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 components

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.

Sequences that support O(1) element access and O(1) length computation.

This class implements a proxy for random access sequences. It forwards all calls to a different sequence object.

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.

Class Seq[A] represents finite sequences of elements of type A.

This class implements a proxy for sequences. It forwards all calls to a different sequence object.

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

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.

Various utilities for instances of Iterable.

The Iterator object provides various functions for creating specialized iterators.

This object provides methods for creating specialized lists, and for transforming special kinds of lists (e.g. lists of lists).

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

The empty list.

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.

The object Stream provides helper functions to manipulate streams.