List

Value Members

1. final def !=(arg0: AnyRef): Boolean

   Definition Classes

   AnyRef

2. final def !=(arg0: Any): Boolean

   Definition Classes

   Any

3. final def ##(): Int

   Definition Classes

   AnyRef → Any

4. def &(that: List[T]): List[T]

5. def ++(that: List[T]): List[T]

6. def +:(e: T): List[T]

7. def -(e: T): List[T]

8. def --(that: List[T]): List[T]

9. def /:[B](z: B)(op: (B, T) ⇒ B): B

10. def :+(t: T): List[T]

11. def ::(t: T): List[T]

12. def :::(prefix: List[T]): List[T]

13. def :\[B](z: B)(op: (T, B) ⇒ B): B

14. final def ==(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

15. final def ==(arg0: Any): Boolean

    Definition Classes

    Any

16. def apply(index: BigInt): T

17. final def asInstanceOf[T0]: T0

    Definition Classes

    Any

18. def chunks(s: BigInt): List[List[T]]

19. def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

20. def contains(v: T): Boolean

21. def content: Set[T]

22. def count(e: T): BigInt

23. def count(p: (T) ⇒ Boolean): BigInt

24. def diff(that: List[T]): List[T]

25. def distinct: List[T]

26. def drop(i: BigInt): List[T]

27. def dropRight(n: BigInt): List[T]

28. def dropWhile(p: (T) ⇒ Boolean): List[T]

29. final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

30. def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

31. def evenSplit: (List[T], List[T])

32. def exists(p: (T) ⇒ Boolean): Boolean

33. def filter(p: (T) ⇒ Boolean): List[T]

34. def filterNot(p: (T) ⇒ Boolean): List[T]

35. def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

36. def find(e: T): Option[BigInt]

37. def find(p: (T) ⇒ Boolean): Option[T]

38. def flatMap[R](f: (T) ⇒ List[R]): List[R]

39. def foldLeft[R](z: R)(f: (R, T) ⇒ R): R

40. def foldRight[R](z: R)(f: (T, R) ⇒ R): R

41. def forall(p: (T) ⇒ Boolean): Boolean

42. final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

43. def groupBy[R](f: (T) ⇒ R): Map[R, List[T]]

44. def hashCode(): Int

    Definition Classes

    AnyRef → Any

45. def head: T

46. def headOption: Option[T]

47. def indexOf(elem: T): BigInt

48. def indexOf(elem: T, from: BigInt): BigInt

49. def indexWhere(p: (T) ⇒ Boolean): BigInt

50. def indexWhere(p: (T) ⇒ Boolean, from: BigInt): BigInt

51. def init: List[T]

52. def insertAt(pos: BigInt, e: T): List[T]

53. def insertAt(pos: BigInt, l: List[T]): List[T]

54. def intersect(that: List[T]): List[T]

55. def isDefinedAt(i: BigInt): Boolean

56. def isEmpty: Boolean

57. final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

58. def isPrefixOf(l: List[T]): Boolean

59. def isSuffixOf(l: List[T]): Boolean

60. def last: T

61. def lastIndexOf(elem: T): BigInt

62. def lastIndexOf(elem: T, end: BigInt): BigInt

63. def lastIndexWhere(p: (T) ⇒ Boolean): BigInt

64. def lastIndexWhere(p: (T) ⇒ Boolean, end: BigInt): BigInt

65. def lastOption: Option[T]

66. def length: BigInt

67. def lengthCompare(len: BigInt): BigInt

68. def map[R](f: (T) ⇒ R): List[R]

69. final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

70. def nonEmpty: Boolean

71. final def notify(): Unit

    Definition Classes

    AnyRef

72. final def notifyAll(): Unit

    Definition Classes

    AnyRef

73. def padTo(s: BigInt, e: T): List[T]

74. def partition(p: (T) ⇒ Boolean): (List[T], List[T])

75. def prefixLength(p: (T) ⇒ Boolean): BigInt

76. def removeFirst(e: T): List[T]

77. def replace(from: T, to: T): List[T]

78. def replaceAt(pos: BigInt, l: List[T]): List[T]

79. def reverse: List[T]

80. def rotate(s: BigInt): List[T]

81. def scanLeft[R](z: R)(f: (R, T) ⇒ R): List[R]

82. def scanRight[R](z: R)(f: (T, R) ⇒ R): List[R]

83. def size: BigInt

84. def slice(from: BigInt, until: BigInt): List[T]

85. def span(p: (T) ⇒ Boolean): (List[T], List[T])

86. def split(seps: List[T]): List[List[T]]

87. def splitAt(e: T): List[List[T]]

88. def splitAt(n: BigInt): (List[T], List[T])

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

    Definition Classes

    AnyRef

90. def tail: List[T]

91. def take(i: BigInt): List[T]

92. def takeRight(n: BigInt): List[T]

93. def takeWhile(p: (T) ⇒ Boolean): List[T]

94. def toString(): String

    Definition Classes

    AnyRef → Any

95. def union(that: List[T]): List[T]

96. def unique: List[T]

97. def updated(i: BigInt, y: T): List[T]

98. final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

100. final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

101. def withFilter(p: (T) ⇒ Boolean): List[T]

102. def zip[B](that: List[B]): List[(T, B)]