LinearSeq

abstract def fromIterable[B](coll: Iterable[B]): LinearSeq[B]

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: A](xs: IterableOnce[B]): LinearSeq[B]

Concatenation

final def ==(arg0: Any): Boolean

def apply(n: Int): A

apply is defined in terms of drop, which is in turn defined in terms of tail.

final def asInstanceOf[T0]: T0

def className: String

The class name of this collection.

def clone(): AnyRef

def coll: LinearSeq.this.type

The collection itself

def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type

Copy all elements of this collection to array xs, starting at start.

def drop(n: Int): LinearSeq[A]

Optimized version of drop that avoids copying Note: drop is defined here, rather than in a trait like LinearSeqMonoTransforms, because the ...MonoTransforms traits make no assumption about the type of Repr whereas we need to assume here that Repr is the same as the underlying collection type.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (A) ⇒ Boolean): LinearSeq[A]

All elements satisfying predicate p

def finalize(): Unit

def flatMap[B](f: (A) ⇒ IterableOnce[B]): LinearSeq[B]

Flatmap

def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

Fold left

def foldRight[B](z: B)(op: (A, B) ⇒ B): B

Fold right

def foreach(f: (A) ⇒ Unit): Unit

Apply f to each element for tis side effects

def fromIterableWithSameElemType(coll: Iterable[A]): LinearSeq[A]

Create a collection of type C[A] from the elements of coll, which has the same element type as this collection.

final def getClass(): Class[_]

def hashCode(): Int

def head: A

The first element of the collection.

def indexWhere(p: (A) ⇒ Boolean): Int

The index of the first element in this collection for which p holds.

def isEmpty: Boolean

Is the collection empty?

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[A]

iterator is overridden in terms of head and tail

def knownSize: Int

The number of elements in this collection, if it can be cheaply computed, -1 otherwise.

def length: Int

length is defined in terms of iterator

def map[B](f: (A) ⇒ B): LinearSeq[B]

Map

def mkString(sep: String): String

A string showing all elements of this collection, separated by string sep.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def partition(p: (A) ⇒ Boolean): (LinearSeq[A], LinearSeq[A])

A pair of, first, all elements that satisfy prediacte p and, second, all elements that do not.

def reverse: LinearSeq[A]

def size: Int

The number of elements in this collection.

final def synchronized[T0](arg0: ⇒ T0): T0

def tail: LinearSeq[A]

The rest of the collection without its first element.

def take(n: Int): LinearSeq[A]

A collection containing the first n elements of this collection.

def to[C[X] <: Iterable[X]](fi: FromIterable[C]): C[A]

Given a collection factory fi for collections of type constructor C, convert this collection to one of type C[A].

def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

Convert collection to array.

def toString(): String

def view: View[A]

A view representing the elements of this collection.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zip[B](xs: IterableOnce[B]): LinearSeq[(A, B)]

Zip.