MappedArraySlice

abstract val array: Array[A]

Underlying array.

abstract val mapF: (A) ⇒ T

Value mapping function.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

final def apply(index: Int): T

Returns value at the given index withing the range.

final def asInstanceOf[T0]: T0

final def asIterable: Iterable[T]

Returns new iterable of Slice values.

def clone(): AnyRef

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

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

Dumps content to the array, starting from an index.

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

Counts values fulfilling the predicate.

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

Lazily narrows Slice to exclude first N items.

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

Lazily narrows Slice to exclude last N items.

final def eq(arg0: AnyRef): Boolean

final def equals(obj: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def hashCode(): Int

final def head: T

Returns first value in the Slice.

final def headOption: Option[T]

Returns first value in the Slice.

final def init: Slice[T]

Returns the Slice without last value.

final def isEmpty: Boolean

Returns true if Slice has values, otherwise false.

final def isInstanceOf[T0]: Boolean

final def iterator: Iterator[T]

Returns iterator over Slice values.

final def last: T

Returns the last value in the Slice.

final def lastOption: Option[T]

Returns the last value in the Slice.

final val length: Int

Sliced range length.

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

Lazily composes mapping function and returns new Slice.

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 reverseIterator(pred: (T) ⇒ Boolean): Iterator[T]

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

final def reverseIterator: Iterator[T]

Returns iterator over Slice values in the reverse order.

final def sameElements(iterator1: Iterator[T], iterator2: Iterator[T]): Boolean

Checks if two iterators would return same elements.

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

Lazily narrows Slice to provided range.

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

final def tail: Slice[T]

Returns the Slice without first value.

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

Lazily narrows Slice to first N items.

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

Lazily narrows Slice to last N items.

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

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

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

Returns buffer with a copy of this Slice.

final def toList: List[T]

Returns new list of Slice values.

final def toString(): String

final def update[T1 >: T](index: Int, value: T)(implicit arg0: ClassTag[T1]): Slice[T1]

Creates a copy of the slice with modified value.

final def wait(): Unit

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

final def wait(arg0: Long): Unit