Slice

abstract def apply(index: Int): T

Returns value at the given index.

abstract def asIterable: Iterable[T]

Returns new iterable of Slice values.

abstract def copyToArray[T1 >: T](targetIndex: Int, targetArray: Array[T1]): Array[T1]

Dumps content to the array, starting from an index.

abstract def count(pred: (T) ⇒ Boolean): Int

Counts values fulfilling the predicate.

abstract def drop(n: Int): Slice[T]

Lazily narrows Slice to exclude first N items.

abstract def dropRight(n: Int): Slice[T]

Lazily narrows Slice to exclude last N items.

abstract def head: T

Returns first value in the Slice.

abstract def headOption: Option[T]

Returns first value in the Slice.

abstract def init: Slice[T]

Returns the Slice without last value.

abstract def isEmpty: Boolean

Returns true if Slice has values, otherwise false.

abstract def iterator: Iterator[T]

Returns iterator over Slice values.

abstract def last: T

Returns the last value in the Slice.

abstract def lastOption: Option[T]

Returns the last value in the Slice.

abstract def length: Int

Returns length of the Slice.

abstract def map[K](f: (T) ⇒ K): Slice[K]

Lazily composes mapping function and returns new Slice.

abstract def reverseIterator(pred: (T) ⇒ Boolean): Iterator[T]

Returns iterator over Slice values, fulfilling the predicate, in the reverse order.

abstract def reverseIterator: Iterator[T]

Returns iterator over Slice values in the reverse order.

abstract def slice(from: Int, to: Int): Slice[T]

Lazily narrows Slice to provided range.

abstract def tail: Slice[T]

Returns the Slice without first value.

abstract def take(n: Int): Slice[T]

Lazily narrows Slice to first N items.

abstract def takeRight(n: Int): Slice[T]

Lazily narrows Slice to last N items.

abstract def toArray[T1 >: T](implicit arg0: ClassTag[T1]): Array[T1]

Returns minimal copy of an underlying array, trimmed to the actual range.

abstract def toBuffer(implicit tag: ClassTag[T]): Buffer[T]

Returns buffer with a copy of this Slice.

abstract def toList: List[T]

Returns new list of Slice values.

abstract def update(index: Int, value: T)(implicit tag: ClassTag[T]): Slice[T]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[A](g: (T) ⇒ A): (Int) ⇒ A

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[A](g: (A) ⇒ Int): (A) ⇒ T

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

Returns true if Slice has values, otherwise false.

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit