Scala 2.8.0.r0-b20090810214045 API

This document is the API specification for Scala Library

Class Summary
case final class :: [B](private hd : B, val tl : List[B]) extends List[B]
A non empty list characterized by a head and a tail.
abstract class BitSet extends Set[Int] with BitSet with BitSetTemplate[BitSet]
a base class for immutable bit sets
class HashMap [A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, HashMap[A, B]] with HashTable[A]
This class implements immutable maps using a hash table. It is optimized for sequential accesses where the last updated table is accessed most often. It supports with reasonable efficiency accesses to previous versions of the table by keeping a change log that's regularly compacted. It needs to synchronize most methods, so it is less suitable for highly concurrent accesses.
class HashSet [A] extends Set[A] with SetClass[A, HashSet] with SetTemplate[A, HashSet[A]] with FlatHashTable[A]
This class implements immutable sets using a hash table. It is optimized for sequential accesses where the last updated table is accessed most often. It supports with reasonable efficiency accesses to previous versions of the table by keeping a change log that's regularly compacted. It needs to synchronize most methods, so it is less suitable for highly concurrent accesses.
sealed abstract class IntMap [+T] extends Map[Int, T] with ImmutableMapTemplate[Int, T, IntMap[T]]
Specialised immutable map structure for integer keys, based on Fast Mergeable Integer Maps by Okasaki and Gill. Essentially a trie based on binary digits of the the integers.
trait Iterable [+A] extends Traversable[A] with Iterable[A] with TraversableClass[A, Iterable] with IterableTemplate[A, Iterable[A]]
A subtrait of collection.Iterable which represents iterables that cannot be mutated.
trait LinearSequence [+A] extends Sequence[A] with LinearSequence[A] with TraversableClass[A, LinearSequence] with LinearSequenceTemplate[A, LinearSequence[A]]
A subtrait of collection.Sequence which represents sequences that cannot be mutated.
sealed abstract class List [+A] extends LinearSequence[A] with Product with TraversableClass[A, List] with LinearSequenceTemplate[A, 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.
class ListMap [A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, ListMap[A, B]]
This class implements immutable maps using a list-based data structure. Instances of ListMap represent empty maps; they can be either created by calling the constructor directly, or by applying the function ListMap.empty.
class ListSet [A] extends Set[A] with SetClass[A, ListSet] with SetTemplate[A, ListSet[A]]
This class implements immutable sets using a list-based data structure. Instances of ListSet represent empty sets; they can be either created by calling the constructor directly, or by applying the function ListSet.empty.
sealed abstract class LongMap [+T] extends Map[Long, T] with ImmutableMapTemplate[Long, T, LongMap[T]]
Specialised immutable map structure for long keys, based on Fast Mergeable Long Maps by Okasaki and Gill. Essentially a trie based on binary digits of the the integers.
trait Map [A, +B] extends Iterable[(A, B)] with Map[A, B] with ImmutableMapTemplate[A, B, Map[A, B]]
trait MapProxy [A, +B] extends Map[A, B] with MapProxyTemplate[A, B, Map[A, B]]
class PagedSeq [T](more : (Array[T], Int, Int) => Int, first1 : scala.collection.immutable.Page[T], start : Int, end : Int) extends Vector[T]
An implementation of lazily computed sequences, where elements are stored in ``pages'', i.e. arrays of fixed size.
class Queue [+A](protected val in : List[A], protected val out : List[A]) extends Sequence[A]
Queue objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.
abstract class RedBlack [A] extends AnyRef
trait Sequence [+A] extends Iterable[A] with Sequence[A] with TraversableClass[A, Sequence] with SequenceTemplate[A, Sequence[A]]
A subtrait of collection.Sequence which represents sequences that cannot be mutated.
trait Set [A] extends Iterable[A] with Set[A] with SetClass[A, Set] with SetTemplate[A, Set[A]]
trait SetProxy [A] extends Set[A] with SetProxyTemplate[A, Set[A]]
trait SortedMap [A, +B] extends Map[A, B] with SortedMap[A, B] with ImmutableMapTemplate[A, B, SortedMap[A, B]] with SortedMapTemplate[A, B, SortedMap[A, B]]
A map whose keys are sorted.
trait SortedSet [A] extends Set[A] with SortedSet[A] with SortedSetTemplate[A, SortedSet[A]]
A sorted set.
class Stack [+A] extends Sequence[A]
This class implements immutable stacks using a list-based data structure. Instances of Stack represent empty stacks; they can be either created by calling the constructor directly, or by applying the function Stack.Empty.
abstract class Stream [+A] extends LinearSequence[A] with TraversableClass[A, Stream] with LinearSequenceTemplate[A, Stream[A]]
trait Traversable [+A] extends Traversable[A] with TraversableClass[A, Traversable] with TraversableTemplate[A, Traversable[A]] with Immutable
A subtrait of Traversable in package collection which represents traversables that cannot be mutated. !!! todo: revise equality
class TreeMap [A, +B](val override size : Int, t : Tree[B], val implicit ordering : Ordering[A]) extends RedBlack[A] with SortedMap[A, B] with SortedMapTemplate[A, B, TreeMap[A, B]] with ImmutableMapTemplate[A, B, TreeMap[A, B]]
This class implements immutable maps using a tree.
class TreeSet [A](val override size : Int, t : Tree[Unit], val implicit ordering : Ordering[A]) extends RedBlack[A] with SortedSet[A] with SortedSetTemplate[A, TreeSet[A]]
This class implements immutable sets using a tree.
trait Vector [+A] extends Sequence[A] with Vector[A] with TraversableClass[A, Vector] with VectorTemplate[A, Vector[A]]
A subtrait of collection.Vector which represents sequences that cannot be mutated.
Object Summary
object :: extends AnyRef
object BitSet extends BitSetFactory[BitSet]
A factory object for bitsets
object HashMap extends ImmutableMapFactory[HashMap]
A factory object for immutable HashMaps.
object HashSet extends SetFactory[HashSet]
A factory object for immutable HashSets
object IntMap extends AnyRef
object Iterable extends TraversableFactory[Iterable]
object LinearSequence extends SequenceFactory[LinearSequence]
object List extends SequenceFactory[List]
This object provides methods for creating specialized lists, and for transforming special kinds of lists (e.g. lists of lists).
object ListMap extends ImmutableMapFactory[ListMap]
The canonical factory of ListMap's
object ListSet extends SetFactory[ListSet]
The canonical factory of ListSet's
object LongMap extends AnyRef
object Map extends ImmutableMapFactory[Map]
case object Nil extends List[Nothing]
The empty list.
object PagedSeq extends AnyRef
The PagedSeq object defines a lazy implementations of a random access sequence.
object Queue extends AnyRef
object Sequence extends SequenceFactory[Sequence]
object Set extends SetFactory[Set]
object SortedMap extends ImmutableSortedMapFactory[SortedMap]
object Stack extends AnyRef
object Stream extends SequenceFactory[Stream]
The object Stream provides helper functions to manipulate streams.
object Traversable extends TraversableFactory[Traversable]
object TreeMap extends ImmutableSortedMapFactory[TreeMap]
The canonical factory of TreeMap's.
object TreeSet extends SortedSetFactory[TreeSet]
The canonical factory of TreeSet's.
object Vector extends SequenceFactory[Vector]