Chain

abstract def isEmpty: Boolean

Returns true if there are no elements in this collection.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[A2 >: A](c: Chain[A2]): Chain[A2]

Alias for concat

final def +:[A2 >: A](a: A2): Chain[A2]

Alias for prepend.

final def :+[A2 >: A](a: A2): Chain[A2]

Alias for append.

final def ==(arg0: Any): Boolean

def ===[AA >: A](that: Chain[AA])(implicit A: Eq[AA]): Boolean

Typesafe equality operator.

final def append[A2 >: A](a: A2): Chain[A2]

Returns a new Chain consisting of this followed by a.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

Collect B from this for which f is defined

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

Finds the first element of this Chain for which the given partial function is defined, and applies the partial function to it.

final def collectFirstSome[B](f: (A) ⇒ Option[B]): Option[B]

Like collectFirst from scala.collection.Traversable but takes A => Option[B] instead of PartialFunctions.

final def concat[A2 >: A](c: Chain[A2]): Chain[A2]

Concatenates this with c in O(1) runtime.

final def contains[AA >: A](a: AA)(implicit A: Eq[AA]): Boolean

Check whether an element is in this structure

final def deleteFirst(f: (A) ⇒ Boolean): Option[(A, Chain[A])]

Yields to Some(a, Chain[A]) with a removed where f holds for the first time, otherwise yields None, if a was not found Traverses only until a is found.

def distinct[AA >: A](implicit O: Order[AA]): Chain[AA]

Remove duplicates.

final def dropWhile(p: (A) ⇒ Boolean): Chain[A]

Drops longest prefix of elements that satisfy a predicate.

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

final def exists(f: (A) ⇒ Boolean): Boolean

Check whether at least one element satisfies the predicate

final def filter(f: (A) ⇒ Boolean): Chain[A]

Remove elements not matching the predicate

final def filterNot(f: (A) ⇒ Boolean): Chain[A]

Remove elements matching the predicate

def finalize(): Unit

final def find(f: (A) ⇒ Boolean): Option[A]

Find the first element matching the predicate, if one exists

final def flatMap[B](f: (A) ⇒ Chain[B]): Chain[B]

Applies the supplied function to each element and returns a new Chain from the concatenated results

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

Folds over the elements from left to right using the supplied initial value and function.

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

Folds over the elements from right to left using the supplied initial value and function.

final def forall(f: (A) ⇒ Boolean): Boolean

Check whether all elements satisfy the predicate

final def getClass(): Class[_]

final def groupBy[B](f: (A) ⇒ B)(implicit B: Order[B]): SortedMap[B, NonEmptyChain[A]]

Groups elements inside this Chain according to the Order of the keys produced by the given mapping function.

def hash[AA >: A](implicit hashA: Hash[AA]): Int

def hashCode(): Int

def headOption: Option[A]

Returns the head of this Chain if non empty, none otherwise.

final def initLast: Option[(Chain[A], A)]

Returns the init and last of this Chain if non empty, none otherwise.

final def isInstanceOf[T0]: Boolean

final def iterator: Iterator[A]

final def lastOption: Option[A]

Returns the last of this Chain if non empty, none otherwise.

final def length: Long

Returns the number of elements in this structure

final def map[B](f: (A) ⇒ B): Chain[B]

Applies the supplied function to each element and returns a new Chain.

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

Returns false if there are no elements in this collection.

final def notify(): Unit

final def notifyAll(): Unit

final def prepend[A2 >: A](a: A2): Chain[A2]

Returns a new Chain consisting of a followed by this.

def reverse: Chain[A]

Reverses this Chain

final def reverseIterator: Iterator[A]

def show[AA >: A](implicit AA: Show[AA]): String

final def size: Long

Alias for length

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

final def takeWhile(p: (A) ⇒ Boolean): Chain[A]

Takes longest prefix of elements that satisfy a predicate.

final def toList: List[A]

Converts to a list.

def toString(): String

final def toVector: Vector[A]

Converts to a vector.

final def uncons: Option[(A, Chain[A])]

Returns the head and tail of this Chain if non empty, none otherwise.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zipWith[B, C](other: Chain[B])(f: (A, B) ⇒ C): Chain[C]

Zips this Chain with another Chain and applies a function for each pair of elements.