ICons

Instance Constructors

new ICons(head: A, tail: IList[A])

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def ++(as: IList[A]): IList[A]

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

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

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

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

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

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

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

Definition Classes
IList
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.
Returns f applied to contents if non-empty, otherwise the zero of B.

Definition Classes
IList
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
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]): IList[B]

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

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

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

Definition Classes
IList
def count(f: (A) ⇒ Boolean): Int

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

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

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

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

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

Definition Classes
IList
final def eq(arg0: AnyRef): Boolean

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

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

Definition Classes
IList
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(f: (A) ⇒ Boolean): Option[A]

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

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

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

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

Definition Classes
IList
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](f: (A) ⇒ K)(implicit ev: Order[K]): ==>>[K, IList[A]]

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

Definition Classes
IList
val head: A
def headOption: Option[A]

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

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

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

Definition Classes
IList
def initOption: Option[IList[A]]

Definition Classes
IList
def inits: IList[IList[A]]

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

Definition Classes
IList
def isEmpty: Boolean

Definition Classes
IList
final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes
IList
final def lastOption: Option[A]

Definition Classes
IList
Annotations
@tailrec()
def length: Int

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

Definition Classes
IList
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.
All of the Bs, in order, and the final C acquired by a stateful left fold over as.

Definition Classes
IList
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.
All of the Bs, in order as-wise, and the final C acquired by a stateful right fold over as.

Definition Classes
IList
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: Boolean

Definition Classes
IList
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

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

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

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

Definition Classes
IList
def prefixLength(f: (A) ⇒ Boolean): Int

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

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

Definition Classes
IList
def reverse: IList[A]

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

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

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

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

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

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

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

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

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

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

Definition Classes
IList
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val tail: IList[A]
def tailOption: Option[IList[A]]

Definition Classes
IList
def tails: IList[IList[A]]

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

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

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

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

Definition Classes
IList
def toEphemeralStream: EphemeralStream[A]

Definition Classes
IList
def toList: List[A]

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

Definition Classes
IList
def toNel: Option[NonEmptyList[A]]

Definition Classes
IList
def toStream: Stream[A]

Definition Classes
IList
def toString(): String

Definition Classes
IList → AnyRef → Any
def toVector: Vector[A]

Definition Classes
IList
def toZipper: Option[Zipper[A]]

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

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

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

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

Definition Classes
IList
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 widen[B](implicit ev: <~<[A, B]): IList[B]

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

Definition Classes
IList
def zipWithIndex: IList[(A, Int)]

Definition Classes
IList

final case class ICons[A](head: A, tail: IList[A]) extends IList[A] with Product with Serializable

Instance Constructors

new ICons(head: A, tail: IList[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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

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

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

final def <^>[B](f: (OneAnd[IList, A]) ⇒ B)(implicit B: Monoid[B]): 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 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 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]]

val head: 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 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])

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

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 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