IList

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

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

alias for concat

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

def +:(a: A): IList[A]

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

alias for foldLeft

def :+(a: A): IList[A]

def ::(a: A): IList[A]

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

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

alias for foldRight

final def <^>[B](f: (OneAnd[IList, A]) ⇒ B)(implicit B: Monoid[B]): B

Returns f applied to contents if non-empty, otherwise the zero of B.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

def concat(as: IList[A]): IList[A]

def containsSlice(as: IList[A])(implicit ev: Equal[A]): Boolean

def count(f: (A) ⇒ Boolean): Int

def distinct(implicit A: Order[A]): IList[A]

def drop(n: Int): IList[A]

def dropRight(n: Int): IList[A]

def dropRightWhile(f: (A) ⇒ Boolean): IList[A]

def dropWhile(f: (A) ⇒ Boolean): IList[A]

def endsWith(as: IList[A])(implicit ev: Equal[A]): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: (A) ⇒ Boolean): IList[A]

def filterNot(f: (A) ⇒ Boolean): IList[A]

def finalize(): Unit

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

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

def flatten[B](implicit ev: <~<[A, IList[B]]): IList[B]

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

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

final def getClass(): Class[_]

def groupBy[K](f: (A) ⇒ K)(implicit ev: Order[K]): ==>>[K, IList[A]]

def groupBy1[K](f: (A) ⇒ K)(implicit ev: Order[K]): ==>>[K, OneAnd[IList, A]]

def hashCode(): Int

def headMaybe: Maybe[A]

def headOption: Option[A]

def indexOf(a: A)(implicit ev: Equal[A]): Option[Int]

def indexOfSlice(slice: IList[A])(implicit ev: Equal[A]): Option[Int]

def indexWhere(f: (A) ⇒ Boolean): Option[Int]

def initOption: Option[IList[A]]

def inits: IList[IList[A]]

def interleave(that: IList[A]): IList[A]

def intersperse(a: A): IList[A]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def lastIndexOf(a: A)(implicit ev: Equal[A]): Option[Int]

def lastIndexOfSlice(as: IList[A])(implicit ev: Equal[A]): Option[Int]

def lastIndexWhere(f: (A) ⇒ Boolean): Option[Int]

final def lastOption: Option[A]

def length: Int

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

def mapAccumLeft[B, C](c: C, f: (C, A) ⇒ (C, B)): (C, IList[B])

All of the Bs, in order, and the final C acquired by a stateful left fold over as.

final def mapAccumRight[B, C](c: C, f: (C, A) ⇒ (C, B)): (C, IList[B])

All of the Bs, in order as-wise, and the final C acquired by a stateful right fold over as.

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def padTo(n: Int, a: A): IList[A]

def partition(f: (A) ⇒ Boolean): (IList[A], IList[A])

def patch(from: Int, patch: IList[A], replaced: Int): IList[A]

def prefixLength(f: (A) ⇒ Boolean): Int

def productIterator: Iterator[Any]

def productPrefix: String

def reduceLeftOption(f: (A, A) ⇒ A): Option[A]

def reduceRightOption(f: (A, A) ⇒ A): Option[A]

def reverse: IList[A]

def reverseMap[B](f: (A) ⇒ B): IList[B]

def reverse_:::(as: IList[A]): IList[A]

def scanLeft[B](z: B)(f: (B, A) ⇒ B): IList[B]

def scanRight[B](z: B)(f: (A, B) ⇒ B): IList[B]

def slice(from: Int, until: Int): IList[A]

def sortBy[B](f: (A) ⇒ B)(implicit B: Order[B]): IList[A]

def sorted(implicit ev: Order[A]): IList[A]

def span(f: (A) ⇒ Boolean): (IList[A], IList[A])

def splitAt(n: Int): (IList[A], IList[A])

def startsWith(as: IList[A])(implicit ev: Equal[A]): Boolean

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

def tailOption: Option[IList[A]]

def tails: IList[IList[A]]

def take(n: Int): IList[A]

def takeRight(n: Int): IList[A]

def takeRightWhile(f: (A) ⇒ Boolean): IList[A]

def takeWhile(f: (A) ⇒ Boolean): IList[A]

def toEphemeralStream: EphemeralStream[A]

def toList: List[A]

def toMap[K, V](implicit ev0: <~<[A, (K, V)], ev1: Order[K]): ==>>[K, V]

def toNel: Option[NonEmptyList[A]]

def toStream: Stream[A]

def toString(): String

def toVector: Vector[A]

def toZipper: Option[Zipper[A]]

def uncons[B](n: ⇒ B, c: (A, IList[A]) ⇒ B): B

def unzip[B, C](implicit ev: <~<[A, (B, C)]): (IList[B], IList[C])

def updated(index: Int, a: A): IList[A]

Unlike stdlib's version, this is total and simply ignores indices that are out of range

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def widen[B](implicit ev: <~<[A, B]): IList[B]

def zip[B](b: ⇒ IList[B]): IList[(A, B)]

def zipWithIndex: IList[(A, Int)]