Packages

sealed abstract class IList[A] extends Product with Serializable

Safe, invariant alternative to stdlib List. Most methods on List have a sensible equivalent here, either on the IList interface itself or via typeclass instances (which are the same as those defined for stdlib List). All methods are total and stack-safe.

Source
IList.scala
Linear Supertypes
Serializable, Serializable, Product, Equals, AnyRef, Any
Known Subclasses
ICons, INil
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IList
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def canEqual(that: Any): Boolean
    Definition Classes
    Equals
  2. abstract def productArity: Int
    Definition Classes
    Product
  3. abstract def productElement(n: Int): Any
    Definition Classes
    Product

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def ++(as: IList[A]): IList[A]

    alias for concat

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

    alias for prepend

  5. def +:(a: A): IList[A]
  6. def /:[B](b: B)(f: (B, A) ⇒ B): B

    alias for foldLeft

  7. def :+(a: A): IList[A]
  8. def ::(a: A): IList[A]
  9. def :::(as: IList[A]): IList[A]
  10. def :\[B](b: B)(f: (A, B) ⇒ B): B

    alias for foldRight

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

  12. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  13. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  14. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  15. def collect[B](pf: PartialFunction[A, B]): IList[B]
  16. def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
  17. def concat(as: IList[A]): IList[A]
  18. def containsSlice(as: IList[A])(implicit ev: Equal[A]): Boolean
  19. def count(f: (A) ⇒ Boolean): Int
  20. def distinct(implicit A: Order[A]): IList[A]
  21. def drop(n: Int): IList[A]
  22. def dropRight(n: Int): IList[A]
  23. def dropRightWhile(f: (A) ⇒ Boolean): IList[A]
  24. def dropWhile(f: (A) ⇒ Boolean): IList[A]
  25. def endsWith(as: IList[A])(implicit ev: Equal[A]): Boolean
  26. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  27. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  28. def filter(f: (A) ⇒ Boolean): IList[A]
  29. def filterNot(f: (A) ⇒ Boolean): IList[A]
  30. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  31. def find(f: (A) ⇒ Boolean): Option[A]
  32. def flatMap[B](f: (A) ⇒ IList[B]): IList[B]
  33. def flatten[B](implicit ev: <~<[A, IList[B]]): IList[B]
  34. def foldLeft[B](b: B)(f: (B, A) ⇒ B): B
  35. def foldRight[B](b: B)(f: (A, B) ⇒ B): B
  36. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  37. def groupBy[K](f: (A) ⇒ K)(implicit ev: Order[K]): ==>>[K, NonEmptyList[A]]
  38. def groupBy1[K](f: (A) ⇒ K)(implicit ev: Order[K]): ==>>[K, OneAnd[IList, A]]
  39. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  40. def headMaybe: Maybe[A]
  41. def headOption: Option[A]
  42. def indexOf(a: A)(implicit ev: Equal[A]): Option[Int]
  43. def indexOfSlice(slice: IList[A])(implicit ev: Equal[A]): Option[Int]
  44. def indexWhere(f: (A) ⇒ Boolean): Option[Int]
  45. def initOption: Option[IList[A]]
  46. def inits: IList[IList[A]]
  47. def interleave(that: IList[A]): IList[A]
  48. def intersperse(a: A): IList[A]
  49. def isEmpty: Boolean
  50. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  51. def lastIndexOf(a: A)(implicit ev: Equal[A]): Option[Int]
  52. def lastIndexOfSlice(as: IList[A])(implicit ev: Equal[A]): Option[Int]
  53. def lastIndexWhere(f: (A) ⇒ Boolean): Option[Int]
  54. final def lastOption: Option[A]
    Annotations
    @tailrec()
  55. def length: Int
  56. def map[B](f: (A) ⇒ B): IList[B]
  57. 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.

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

  59. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  60. def nonEmpty: Boolean
  61. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  62. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  63. def padTo(n: Int, a: A): IList[A]
  64. def partition(f: (A) ⇒ Boolean): (IList[A], IList[A])
  65. def patch(from: Int, patch: IList[A], replaced: Int): IList[A]
  66. def prefixLength(f: (A) ⇒ Boolean): Int
  67. def prepend(as: IList[A]): IList[A]
  68. def productIterator: Iterator[Any]
    Definition Classes
    Product
  69. def productPrefix: String
    Definition Classes
    Product
  70. def reduceLeftOption(f: (A, A) ⇒ A): Option[A]
  71. def reduceRightOption(f: (A, A) ⇒ A): Option[A]
  72. def reverse: IList[A]
  73. def reverseMap[B](f: (A) ⇒ B): IList[B]
  74. def reverse_:::(as: IList[A]): IList[A]
  75. def scanLeft[B](z: B)(f: (B, A) ⇒ B): IList[B]
  76. def scanRight[B](z: B)(f: (A, B) ⇒ B): IList[B]
  77. def slice(from: Int, until: Int): IList[A]
  78. def sortBy[B](f: (A) ⇒ B)(implicit B: Order[B]): IList[A]
  79. def sorted(implicit ev: Order[A]): IList[A]
  80. def span(f: (A) ⇒ Boolean): (IList[A], IList[A])
  81. def splitAt(n: Int): (IList[A], IList[A])
  82. def startsWith(as: IList[A])(implicit ev: Equal[A]): Boolean
  83. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  84. def tailOption: Option[IList[A]]
  85. def tails: IList[IList[A]]
  86. def take(n: Int): IList[A]
  87. def takeRight(n: Int): IList[A]
  88. def takeRightWhile(f: (A) ⇒ Boolean): IList[A]
  89. def takeWhile(f: (A) ⇒ Boolean): IList[A]
  90. def toEphemeralStream: EphemeralStream[A]
  91. def toList: List[A]
  92. def toMap[K, V](implicit ev0: <~<[A, (K, V)], ev1: Order[K]): ==>>[K, V]
  93. def toNel: Option[NonEmptyList[A]]
  94. def toStream: Stream[A]
  95. def toString(): String
    Definition Classes
    IList → AnyRef → Any
  96. def toVector: Vector[A]
  97. def toZipper: Option[Zipper[A]]
  98. def traverseDisjunction[E, B](f: (A) ⇒ \/[E, B]): \/[E, IList[B]]

    Referentially transparent replacement for traverse, specialised to disjunction.

  99. def uncons[B](n: ⇒ B, c: (A, IList[A]) ⇒ B): B
  100. def unzip[B, C](implicit ev: <~<[A, (B, C)]): (IList[B], IList[C])
  101. def updated(index: Int, a: A): IList[A]

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

  102. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  103. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  104. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  105. def widen[B](implicit ev: <~<[A, B]): IList[B]
  106. def zip[B](b: ⇒ IList[B]): IList[(A, B)]
  107. def zipWithIndex: IList[(A, Int)]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped