LIterable

Type Members

type Repr = LArray[A]
class SlidingIterator extends AbstractLIterator[LSeq.Repr]

Abstract Value Members

abstract def newBuilder: LBuilder[A, LSeq.Repr]

Attributes
protected[this]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(other: LSeq[A]): LSeq.Repr

Create a new array that concatenates two arrays
def +:(elem: A): LSeq.Repr

Copy of thie array with an element prepended.
Copy of thie array with an element prepended.
elem
the prepended element.
returns
a new array consisting ofall elements of this array preceded by the new elem.
def /:[B](z: B)(op: (B, A) ⇒ B): B

fold left
fold left
B
the result type of the binary operator
z
the start value
op
the binary operator
returns
the result of inserting op between consecutive elements of this array, going left to right with the start value z on the left:
```
op(...op(op(z, x1), x2), ..., xn)))
```
def :+(elem: A): LSeq.Repr

Copy of this array with an element appended.
Copy of this array with an element appended.
elem
the appended element
returns
a new array consisting of all elements of this array follwed by the new elem
def :\[B](z: B)(op: (A, B) ⇒ B): B

fold right
fold right
B
the result type of the binary operator
z
the start value
op
the binary operator
returns
the result of inserting op between consecutive elements of this array, going right to left with the start value z on the right:
```
op(x1, op(x2, ..., op(xn, z)...))
```
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
def aggregate[B](z: B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](pf: PartialFunction[A, B]): LIterator[B]

Builds a new collection by applying a partial function to all elments of this array on which the function is defined.
def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

Finds the first element of this array on which the given partial function is defined, and applies the partial function to it.
Finds the first element of this array on which the given partial function is defined, and applies the partial function to it.
B
return type
pf
partial function
returns
an option value containing pf applied to the first value for which the function is defined, or None if not exists.
def concat(other: LSeq[A]): LSeq.Repr

Create a new array that concatenates two arrays
def contains(elem: A): Boolean
def copyToArray[B >: A](xs: LArray[B], start: Long, len: Long): Unit
def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit
def drop(n: Long): LSeq.Repr
def dropWhile(p: (A) ⇒ Boolean): LSeq.Repr
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(p: (A) ⇒ Boolean): Boolean
def filter(pred: (A) ⇒ Boolean): LIterator[A]
def filterNot(pred: (A) ⇒ Boolean): LIterator[A]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (A) ⇒ Boolean): Option[A]
def flatMap[B](f: (A) ⇒ LIterator[B]): LIterator[B]
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
def foldRight[B](z: B)(op: (A, B) ⇒ B): B
def forall(p: (A) ⇒ Boolean): Boolean
def foreach[U](f: (A) ⇒ U): Unit
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: A
def indexOf[B >: A](elem: B): Long
def indexWhere(p: (A) ⇒ Boolean, from: Long): Long
def init: LSeq.Repr
def isEmpty: Boolean

Tests whether this sequence is empty
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterator: LIterator[A]

Creates a new iterator over all elements contained in this collection
def ji: Iterable[A]

Provides the Iterable interface for Java
def last: A
def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int
def length: Long
def map[B](f: (A) ⇒ B): LIterator[B]
def mkString: String
def mkString(sep: String): String
def mkString(start: String, sep: String, end: String): String
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def partition(p: (A) ⇒ Boolean): (LIterator[A], LIterator[A])
def prefixLength(p: (A) ⇒ Boolean): Long
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
def reduceLeft[B >: A](op: (B, A) ⇒ B): B
def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
def reduceRight[B >: A](op: (A, B) ⇒ B): B
def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
def reverse[A]: LSeq.Repr
def reverseIterator: LIterator[A]
def sameElements[B >: A](that: LIterable[B]): Boolean
def scanLeft[B](z: B)(op: (B, A) ⇒ B): LIterator[B]
def segmentLength(p: (A) ⇒ Boolean, from: Long): Long
def slice(from: Long, until: Long): LArray[A]
def slice(from: Long): LArray[A]
def sliding(size: Long, step: Long): LIterator[LSeq.Repr]

Groups elemnts in fixed size blocks by passing a 'sliding window' over them.
Groups elemnts in fixed size blocks by passing a 'sliding window' over them.
size
the number of elements per group
step
the distance between the first elements of successive groups
returns
An itertor producing group of elements.
def sliding(size: Int): LIterator[LSeq.Repr]

Groups elements in fixed size blocks by passing a 'sliding window' over them
Groups elements in fixed size blocks by passing a 'sliding window' over them
size
the number of elements per group
returns
An iterator producing group of elements.
def span(p: (A) ⇒ Boolean): (LSeq.Repr, LSeq.Repr)
def splitAt(n: Long): (LSeq.Repr, LSeq.Repr)
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: LArray[A]
def take(n: Long): LSeq.Repr
def takeRight(n: Long): LSeq.Repr
def takeWhile(p: (A) ⇒ Boolean): LSeq.Repr
def toArray[A1 >: A](implicit arg0: ClassTag[A1]): Array[A1]

Creates a copy of this array in the form of the standard Scala Array
def toIterator: LIterator[A]
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withFilter(p: (A) ⇒ Boolean): LIterator[A]
def zip[B](that: LIterable[B]): LIterator[(A, B)]
def zipAll[B, A1 >: A, B1 >: B](that: LIterable[B], thisElem: A1, thatElem: B1): LIterator[(A1, B1)]
def zipWithIndex: LIterator[(A, Long)]

Related Doc: package larray

trait LIterable[A] extends AnyRef

Type Members

type Repr = LArray[A]

class SlidingIterator extends AbstractLIterator[LSeq.Repr]

Abstract Value Members

abstract def newBuilder: LBuilder[A, LSeq.Repr]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: LSeq[A]): LSeq.Repr

def +:(elem: A): LSeq.Repr

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

def :+(elem: A): LSeq.Repr

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

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B](pf: PartialFunction[A, B]): LIterator[B]

def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

def concat(other: LSeq[A]): LSeq.Repr

def contains(elem: A): Boolean

def copyToArray[B >: A](xs: LArray[B], start: Long, len: Long): Unit

def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

def drop(n: Long): LSeq.Repr

def dropWhile(p: (A) ⇒ Boolean): LSeq.Repr

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (A) ⇒ Boolean): Boolean

def filter(pred: (A) ⇒ Boolean): LIterator[A]

def filterNot(pred: (A) ⇒ Boolean): LIterator[A]

def finalize(): Unit

def find(p: (A) ⇒ Boolean): Option[A]

def flatMap[B](f: (A) ⇒ LIterator[B]): LIterator[B]

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

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

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

def forall(p: (A) ⇒ Boolean): Boolean

def foreach[U](f: (A) ⇒ U): Unit

final def getClass(): Class[_]

def hashCode(): Int

def head: A

def indexOf[B >: A](elem: B): Long

def indexWhere(p: (A) ⇒ Boolean, from: Long): Long

def init: LSeq.Repr

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def iterator: LIterator[A]

def ji: Iterable[A]

def last: A

def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int

def length: Long

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

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def prefixLength(p: (A) ⇒ Boolean): Long

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: A](op: (B, A) ⇒ B): B

def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: A](op: (A, B) ⇒ B): B

def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

def reverse[A]: LSeq.Repr

def reverseIterator: LIterator[A]

def sameElements[B >: A](that: LIterable[B]): Boolean

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

def segmentLength(p: (A) ⇒ Boolean, from: Long): Long

def slice(from: Long, until: Long): LArray[A]

def slice(from: Long): LArray[A]

def sliding(size: Long, step: Long): LIterator[LSeq.Repr]

def sliding(size: Int): LIterator[LSeq.Repr]

def span(p: (A) ⇒ Boolean): (LSeq.Repr, LSeq.Repr)