LazyMapArraySlice

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.

final def asArray: Array[T]

Returns an array of mapped values.

final def asBuffer: Buffer[T]

Returns a buffer with a copy of this Slice.

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

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 detach: LazyMapArraySlice.this.type

Detaches a slice creating a trimmed copy of an underlying data.

final def drop(n: Int): LazyMapArraySlice.this.type

Lazily narrows Slice to exclude first N items.

final def dropRight(n: Int): LazyMapArraySlice.this.type

Lazily narrows Slice to exclude last N items.

final def eq(arg0: AnyRef): Boolean

final def equals(obj: Any): Boolean

final def exists(pred: (T) ⇒ Boolean): Boolean

Returns true if any value fulfills the predicate, or false.

def finalize(): Unit

final def find(pred: (T) ⇒ Boolean): Option[T]

Returns Some of the first value fulfilling the predicate, or None.

final def fold(initial: T)(f: (T, T) ⇒ T): T

Combines from left to right all elements, starting with initial.

final def foldLeft[R](initial: R)(f: (R, T) ⇒ R): R

Folds from left to right all elements, starting with initial.

final def foldRight[R](initial: R)(f: (T, R) ⇒ R): R

Folds from right to left all elements, starting with initial.

final def get(index: Int): Option[T]

Returns Some of the value at the index, or None if index outside of range.

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

Returns iterator over Slice indexes of values fulfilling the predicate.

final def init: LazyMapArraySlice.this.type

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

Returns iterator over Slice values fulfilling the predicate.

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): LazyMapArraySlice[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 read(index: Int): T

Returns value at the given index

final def reduce(f: (T, T) ⇒ T): T

Combines from right to left all elements.

final def reverseIndexIterator(pred: (T) ⇒ Boolean): Iterator[Int]

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

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 slice(from: Int, to: Int): LazyMapArraySlice.this.type

Lazily narrows Slice to provided range.

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

final def tail: LazyMapArraySlice.this.type

Returns the Slice without first value.

final def take(n: Int): LazyMapArraySlice.this.type

Lazily narrows Slice to first N items.

final def takeRight(n: Int): LazyMapArraySlice.this.type

Lazily narrows Slice to last N items.

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

Returns a trimmed copy of an underlying array.

final def toBuffer[T1 >: T]: Buffer[T1]

Returns buffer with a copy of this Slice.

final def toList: List[T]

Returns new list of Slice values.

final def toSeq: Seq[T]

Returns new sequence of Slice values.

final def toString(): String

final def top: Int

Returns top index value (length-1).

final def update[T1 >: T](index: Int, value: 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