Scaladoc for scala.collection.immutable.IndexedSeq

Inherits

SeqFactory
TraversableFactory
GenericCompanion
AnyRef
Any

Type Members

type Coll = CC[_]

The underlying collection type with unknown element type

The underlying collection type with unknown element type

definition classes: GenericCompanion

Go to: companion
class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]]

A generic implementation of the CanBuildFrom trait, which forwards all calls to apply(from) to the genericBuilder methof of collection from, and which forwards all calls of apply() to the newBuilder method of this factory
class Impl[A] extends IndexedSeq[A]

Value Members

def apply[A](elems: A*): CC[A]

Creates a collection with the specified elements

Creates a collection with the specified elements.

elems
the elements of the created collection
returns
a new collection with elements elems

definition classes: GenericCompanion

Go to: companion
def canBuildFrom[A]: CanBuildFrom[scala.collection.immutable.IndexedSeq[_], A, IndexedSeq[A]]
def concat[A](xss: Traversable[A]*): CC[A]

Concatenates all argument collections into a single collection

Concatenates all argument collections into a single collection.

xss
the collections that are to be concatenated.
returns
the concatenation of all the collections.

definition classes: TraversableFactory

Go to: companion
def empty[A]: CC[A]

The empty collection of type CC[A]

The empty collection of type CC[A]

definition classes: GenericCompanion

Go to: companion
def equals(arg0: Any): Boolean

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence
This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.
The default implementations of this method is an equivalence relation:
- It is reflexive: for any instance x of type Any, x.equals(x) should return true.
- It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true.
- It is transitive: for any instances x, y, and z of type AnyRef if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override hashCode to ensure that objects that are "equal" (o1.equals(o2) returns true) hash to the same Int (o1.hashCode.equals(o2.hashCode)).
arg0
the object to compare against this object for equality.
returns
true if the receiver object is equivalent to the argument; false otherwise.

definition classes: AnyRef ⇐ Any

Go to: companion
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: ⇒ A): CC[CC[CC[CC[CC[A]]]]]

Produces a five-dimensional collection containing the results of some element computation a number of times

Produces a five-dimensional collection containing the results of some element computation a number of times.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
n3
the number of elements in the 3nd dimension
n4
the number of elements in the 4th dimension
n5
the number of elements in the 5th dimension
elem
the element computation
returns
A collection that contains the results of n1 x n2 x n3 x n4 x n5 evaluations of elem.

definition classes: TraversableFactory

Go to: companion
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: ⇒ A): CC[CC[CC[CC[A]]]]

Produces a four-dimensional collection containing the results of some element computation a number of times

Produces a four-dimensional collection containing the results of some element computation a number of times.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
n3
the number of elements in the 3nd dimension
n4
the number of elements in the 4th dimension
elem
the element computation
returns
A collection that contains the results of n1 x n2 x n3 x n4 evaluations of elem.

definition classes: TraversableFactory

Go to: companion
def fill[A](n1: Int, n2: Int, n3: Int)(elem: ⇒ A): CC[CC[CC[A]]]

Produces a three-dimensional collection containing the results of some element computation a number of times

Produces a three-dimensional collection containing the results of some element computation a number of times.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
n3
the number of elements in the 3nd dimension
elem
the element computation
returns
A collection that contains the results of n1 x n2 x n3 evaluations of elem.

definition classes: TraversableFactory

Go to: companion
def fill[A](n1: Int, n2: Int)(elem: ⇒ A): CC[CC[A]]

Produces a two-dimensional collection containing the results of some element computation a number of times

Produces a two-dimensional collection containing the results of some element computation a number of times.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
elem
the element computation
returns
A collection that contains the results of n1 x n2 evaluations of elem.

definition classes: TraversableFactory

Go to: companion
def fill[A](n: Int)(elem: ⇒ A): CC[A]

Produces a collection containing the results of some element computation a number of times

Produces a collection containing the results of some element computation a number of times.

n
the number of elements contained in the collection.
elem
the element computation
returns
A collection that contains the results of n evaluations of elem.

definition classes: TraversableFactory

Go to: companion
def hashCode(): Int

Returns a hash code value for the object

Returns a hash code value for the object.
The default hashing algorithm is platform dependent.
Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

definition classes: AnyRef ⇐ Any

Go to: companion
def iterate[A](start: A, len: Int)(f: (A) ⇒ A): CC[A]

Produces a collection containing repeated applications of a function to a start value

Produces a collection containing repeated applications of a function to a start value.

start
the start value of the collection
len
the number of elements contained inthe collection
f
the function that's repeatedly applied
returns
a collection with len values in the sequence start, f(start), f(f(start)), ...

definition classes: TraversableFactory

Go to: companion
def newBuilder[A]: Builder[A, IndexedSeq[A]]

The default builder for CC objects

The default builder for CC objects.

definition classes: IndexedSeq ⇐ GenericCompanion

Go to: companion
def range(start: Int, end: Int, step: Int): CC[Int]

Produces a collection containing equally spaced values in some integer interval

Produces a collection containing equally spaced values in some integer interval.

start
the start value of the collection
end
the end value of the collection (the first value NOT contained)
step
the difference between successive elements of the collection (must be positive or negative)
returns
a collection with values start, start + step, ... up to, but excluding end

definition classes: TraversableFactory

Go to: companion
def range(start: Int, end: Int): CC[Int]

Produces a collection containing a sequence of increasing of integers

Produces a collection containing a sequence of increasing of integers.

end
the end value of the collection (the first value NOT contained)
returns
a collection with values start, start + 1, ..., end - 1

definition classes: TraversableFactory

Go to: companion
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) ⇒ A): CC[CC[CC[CC[CC[A]]]]]

Produces a five-dimensional collection containing values of a given function over ranges of integer values starting from 0

Produces a five-dimensional collection containing values of a given function over ranges of integer values starting from 0.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
n3
the number of elements in the 3nd dimension
n4
the number of elements in the 4th dimension
n5
the number of elements in the 5th dimension
f
The function computing element values
returns
A collection consisting of elements f(i1, i2, i3, i4, i5) for 0 <= i1 < n1, 0 <= i2 < n2, 0 <= i3 < n3, 0 <= i4 < n4, and 0 <= i5 < n5.

definition classes: TraversableFactory

Go to: companion
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) ⇒ A): CC[CC[CC[CC[A]]]]

Produces a four-dimensional collection containing values of a given function over ranges of integer values starting from 0

Produces a four-dimensional collection containing values of a given function over ranges of integer values starting from 0.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
n3
the number of elements in the 3nd dimension
n4
the number of elements in the 4th dimension
f
The function computing element values
returns
A collection consisting of elements f(i1, i2, i3, i4) for 0 <= i1 < n1, 0 <= i2 < n2, 0 <= i3 < n3, and 0 <= i4 < n4.

definition classes: TraversableFactory

Go to: companion
def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) ⇒ A): CC[CC[CC[A]]]

Produces a three-dimensional collection containing values of a given function over ranges of integer values starting from 0

Produces a three-dimensional collection containing values of a given function over ranges of integer values starting from 0.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
n3
the number of elements in the 3nd dimension
f
The function computing element values
returns
A collection consisting of elements f(i1, i2, i3) for 0 <= i1 < n1, 0 <= i2 < n2, and 0 <= i3 < n3.

definition classes: TraversableFactory

Go to: companion
def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) ⇒ A): CC[CC[A]]

Produces a two-dimensional collection containing values of a given function over ranges of integer values starting from 0

Produces a two-dimensional collection containing values of a given function over ranges of integer values starting from 0.

n1
the number of elements in the 1st dimension
n2
the number of elements in the 2nd dimension
f
The function computing element values
returns
A collection consisting of elements f(i1, i2) for 0 <= i1 < n1 and 0 <= i2 < n2.

definition classes: TraversableFactory

Go to: companion
def tabulate[A](n: Int)(f: (Int) ⇒ A): CC[A]

Produces a collection containing values of a given function over a range of integer values starting from 0

Produces a collection containing values of a given function over a range of integer values starting from 0.

n
The number of elements in the collection
f
The function computing element values
returns
A collection consisting of elements f(0), ..., f(n -1)

definition classes: TraversableFactory

Go to: companion
def toString(): String

Returns a string representation of the object

Returns a string representation of the object.
The default representation is platform dependent.

definition classes: AnyRef ⇐ Any

Go to: companion
def unapplySeq[A](x: CC[A]): Some[CC[A]]

This method is called in a pattern match { case Seq(

This method is called in a pattern match { case Seq(...) => }.

x
the selector value
returns
sequence wrapped in an option, if this is a Seq, otherwise none

definition classes: SeqFactory

Go to: companion

IndexedSeq

object IndexedSeq extends SeqFactory[IndexedSeq[A][A]]

Inherits

Type Members

type Coll = CC[_]

class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]]

class Impl[A] extends IndexedSeq[A]

Value Members

def apply[A](elems: A*): CC[A]

def canBuildFrom[A]: CanBuildFrom[scala.collection.immutable.IndexedSeq[_], A, IndexedSeq[A]]

def concat[A](xss: Traversable[A]*): CC[A]

def empty[A]: CC[A]

def equals(arg0: Any): Boolean

def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: ⇒ A): CC[CC[CC[CC[CC[A]]]]]

def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: ⇒ A): CC[CC[CC[CC[A]]]]

def fill[A](n1: Int, n2: Int, n3: Int)(elem: ⇒ A): CC[CC[CC[A]]]

def fill[A](n1: Int, n2: Int)(elem: ⇒ A): CC[CC[A]]

def fill[A](n: Int)(elem: ⇒ A): CC[A]

def hashCode(): Int

def iterate[A](start: A, len: Int)(f: (A) ⇒ A): CC[A]

def newBuilder[A]: Builder[A, IndexedSeq[A]]

def range(start: Int, end: Int, step: Int): CC[Int]

def range(start: Int, end: Int): CC[Int]

def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) ⇒ A): CC[CC[CC[CC[CC[A]]]]]

def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) ⇒ A): CC[CC[CC[CC[A]]]]

def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) ⇒ A): CC[CC[CC[A]]]

def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) ⇒ A): CC[CC[A]]

def tabulate[A](n: Int)(f: (Int) ⇒ A): CC[A]

def toString(): String

def unapplySeq[A](x: CC[A]): Some[CC[A]]