List

abstract def isEmpty: Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(as: List[A]): List[A]

Append a list to this list.

final def ::(a: A): Nel[A]

Prepend the given value to this List O(1)

def :::(as: List[A]): List[A]

Append a list to this list.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def coflatMap[B](f: (List[A]) ⇒ B): List[B]

Apply a function extracting a B from every sublist, accumuating all the Bs into a List O(n)

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

Returns true if the given value is present in the List.

final def drop(num: Int): List[A]

Returns a List containing the first n elements of this List, if n * < the length of this list, the result will be a copy of this list.

final def dropWhile(pred: (A) ⇒ Boolean): List[A]

Returns the list with the longest prefix of As matching the given predicate removed.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

Returns true of any element in the List matches the given predicate.

final def filter(pred: (A) ⇒ Boolean): List[A]

Construct a new List containing only elements of this List which pass the given predicate O(n)

def finalize(): Unit

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

Return the first element in the List matching the given predicate, if one is found at all.

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

Apply a function returning a List to each element of this List, return a List which is the concatenation of all the resulting Lists.

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

A left-associated fold of the List, which accumuates a B value by passing each element of the List to the given accumulating function.

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

A right-associative fold on the list which evaluates the tail of the list lazily, allowing this computation to terminate before evailuating all of the elements on the list O(n)

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

Returns true of all elements in the List match the given predicate.

def foreach(f: (A) ⇒ Unit): Unit

Execute the side-effecting function on each memeber of the list, in order

final def getClass(): Class[_]

def hashCode(): Int

final def headOption: Option[A]

Return the head of the list, if one exists

final def isInstanceOf[T0]: Boolean

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

Apply a function to each element of this list, producing a new list with the results.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reverse: List[A]

Return a List which contains all of the same elements as this List, but in the opposite order O(n)

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

final def tailOption: Option[List[A]]

Return the tail of the list, if one exists

final def tails: Streaming[List[A]]

Returns a stream of Lists.

def take(num: Int): List[A]

Returns a List containing the first n elements of this List, if n < the length of this list, the result will be a copy of this list.

final def takeWhile(pred: (A) ⇒ Boolean): List[A]

Returns the longest prefix of elements which match the given predicate.

final def toNel: Option[Nel[A]]

def toScalaList: scala.List[A]

def toString(): String

final def unzip[B, C](implicit unz: =:=[(B, C), A]): (List[B], List[C])

If there is proof that this is a list of (B,C) return a tuple of the lists with the elements separated

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zip[B](bs: List[B]): List[(A, B)]

Returns a list of (A,B) pairs.

final def zipWithIndex: List[(A, Int)]

Returns a list of (A,Int) where each A is paired with its zero-based index in the list