scala.collection.immutable.ListSet

Node

class Node extends ListSet[A]

Represents an entry in the ListSet.

attributes: protected
source: ListSet.scala
Inherited
  1. Hide All
  2. Show all
  1. ListSet
  2. Set
  3. Set
  4. SetLike
  5. Subtractable
  6. Addable
  7. GenericSetTemplate
  8. Function1
  9. Iterable
  10. Iterable
  11. IterableLike
  12. Equals
  13. Traversable
  14. Immutable
  15. Traversable
  16. GenericTraversableTemplate
  17. TraversableLike
  18. TraversableOnce
  19. FilterMonadic
  20. HasNewBuilder
  21. AnyRef
  22. Any
Visibility
  1. Public
  2. All

Instance constructors

  1. new Node(elem: A)

Type Members

  1. class Node extends ListSet[A]

    Represents an entry in the ListSet.

  2. type Self = ListSet[A]

    The type implementing this traversable

  3. class WithFilter extends FilterMonadic[A, Repr]

    A class supporting filtered operations.

Value Members

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

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

    o != arg0 is the same as !(o == (arg0)).

  3. def ##(): Int

  4. def $asInstanceOf[T0](): T0

  5. def $isInstanceOf[T0](): Boolean

  6. def &(that: Set[A]): ListSet[A]

    Computes the intersection between this set and another set.

  7. def &~(that: Set[A]): ListSet[A]

    The difference of this set and another set.

  8. def **(that: Set[A]): ListSet[A]

    This method is an alias for intersect.

  9. def +(e: A): ListSet[A]

    This method creates a new set with an additional element.

  10. def +(elem1: A, elem2: A, elems: A*): ListSet[A]

    Creates a new immutable list set with additional elements.

  11. def ++(xs: TraversableOnce[A]): ListSet[A]

    Creates a new immutable list set by adding all elements contained in another collection to this immutable list set.

  12. def ++(that: TraversableOnce[A]): Traversable[A]

    [use case] Concatenates this immutable list set with the elements of a traversable collection.

  13. def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[ListSet[A], B, That]): That

    Concatenates this immutable list set with the elements of a traversable collection.

  14. def -(e: A): ListSet[A]

    - can be used to remove a single element from a set.

  15. def -(elem1: A, elem2: A, elems: A*): ListSet[A]

    Creates a new immutable list set from this immutable list set with some elements removed.

  16. def --(xs: TraversableOnce[A]): ListSet[A]

    Creates a new immutable list set from this immutable list set by removing all elements of another collection.

  17. def /:[B](z: B)(op: (B, A) ⇒ B): B

    Applies a binary operator to a start value and all elements of this immutable list set, going left to right.

  18. def :\[B](z: B)(op: (A, B) ⇒ B): B

    Applies a binary operator to all elements of this immutable list set and a start value, going right to left.

  19. def ==(arg0: AnyRef): Boolean

    o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

  20. def ==(arg0: Any): Boolean

    o == arg0 is the same as o.equals(arg0).

  21. def addString(b: StringBuilder): StringBuilder

    Appends all elements of this immutable list set to a string builder.

  22. def addString(b: StringBuilder, sep: String): StringBuilder

    Appends all elements of this immutable list set to a string builder using a separator string.

  23. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Appends all elements of this immutable list set to a string builder using start, end, and separator strings.

  24. def andThen[A](g: (Boolean) ⇒ A): (A) ⇒ A

    (f andThen g)(x) == g(f(x))

  25. def apply(elem: A): Boolean

    Tests if some element is contained in this set.

  26. def asInstanceOf[T0]: T0

    This method is used to cast the receiver object to be of type T0.

  27. def canEqual(that: Any): Boolean

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.

  28. def clone(): AnyRef

    This method creates and returns a copy of the receiver object.

  29. def collect[B](pf: PartialFunction[A, B]): Traversable[B]

    [use case] Builds a new collection by applying a partial function to all elements of this immutable list set on which the function is defined.

  30. def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[ListSet[A], B, That]): That

    Builds a new collection by applying a partial function to all elements of this immutable list set on which the function is defined.

  31. def companion: GenericCompanion[ListSet[A][A]]

    The factory companion object that builds instances of class immutable.

  32. def compose[A](g: (A) ⇒ A): (A) ⇒ Boolean

    (f compose g)(x) == f(g(x))

  33. def contains(e: A): Boolean

    Checks if this set contains element elem.

  34. def copyToArray(xs: Array[A], start: Int, len: Int): Unit

    [use case] Copies elements of this immutable list set to an array.

  35. def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

    Copies elements of this immutable list set to an array.

  36. def copyToArray(xs: Array[A]): Unit

    [use case] Copies values of this immutable list set to an array.

  37. def copyToArray[B >: A](xs: Array[B]): Unit

    Copies values of this immutable list set to an array.

  38. def copyToArray(xs: Array[A], start: Int): Unit

    [use case] Copies values of this immutable list set to an array.

  39. def copyToArray[B >: A](xs: Array[B], start: Int): Unit

    Copies values of this immutable list set to an array.

  40. def copyToBuffer[B >: A](dest: Buffer[B]): Unit

    Copies all elements of this immutable list set to a buffer.

  41. def count(p: (A) ⇒ Boolean): Int

    Counts the number of elements in the immutable list set which satisfy a predicate.

  42. def diff(that: Set[A]): ListSet[A]

    Computes the difference of this set and another set.

  43. def drop(n: Int): ListSet[A]

    Selects all elements except first n ones.

  44. def dropRight(n: Int): ListSet[A]

    Selects all elements except last n ones.

  45. def dropWhile(p: (A) ⇒ Boolean): ListSet[A]

    Drops longest prefix of elements that satisfy a predicate.

  46. val elem: A

    no summary matey

  47. def elements: Iterator[A]

  48. def empty: ListSet[A]

  49. def eq(arg0: AnyRef): Boolean

    This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

  50. def equals(that: Any): Boolean

    Compares this set with another object for equality.

  51. def exists(p: (A) ⇒ Boolean): Boolean

    Tests whether a predicate holds for some of the elements of this immutable list set.

  52. def filter(p: (A) ⇒ Boolean): ListSet[A]

    Selects all elements of this immutable list set which satisfy a predicate.

  53. def filterNot(p: (A) ⇒ Boolean): ListSet[A]

    Selects all elements of this immutable list set which do not satisfy a predicate.

  54. def finalize(): Unit

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

  55. def find(p: (A) ⇒ Boolean): Option[A]

    Finds the first element of the immutable list set satisfying a predicate, if any.

  56. def first: A

  57. def firstOption: Option[A]

    None if iterable is empty.

  58. def flatMap[B](f: (A) ⇒ Traversable[B]): Traversable[B]

    [use case] Builds a new collection by applying a function to all elements of this immutable list set and concatenating the results.

  59. def flatMap[B, That](f: (A) ⇒ Traversable[B])(implicit bf: CanBuildFrom[ListSet[A], B, That]): That

    Builds a new collection by applying a function to all elements of this immutable list set and concatenating the results.

  60. def flatten[B]: CC[B]

    [use case] Converts this immutable list set of traversable collections into a immutable list set in which all element collections are concatenated.

  61. def flatten[B](implicit asTraversable: (A) ⇒ Traversable[B]): ListSet[B]

    Converts this immutable list set of traversable collections into a immutable list set in which all element collections are concatenated.

  62. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Applies a binary operator to a start value and all elements of this immutable list set, going left to right.

  63. def foldRight[B](z: B)(op: (A, B) ⇒ B): B

    Applies a binary operator to all elements of this immutable list set and a start value, going right to left.

  64. def forall(p: (A) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this immutable list set.

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

    [use case] Applies a function f to all elements of this immutable list set.

  66. def foreach[U](f: (A) ⇒ U): Unit

    Applies a function f to all elements of this immutable list set.

  67. def genericBuilder[B]: Builder[B, ListSet[B]]

    The generic builder that builds instances of immutable.

  68. def getClass(): java.lang.Class[_ <: java.lang.Object]

    Returns a representation that corresponds to the dynamic class of the receiver object.

  69. def groupBy[K](f: (A) ⇒ K): Map[K, ListSet[A]]

    Partitions this immutable list set into a map of immutable list sets according to some discriminator function.

  70. def grouped(size: Int): Iterator[ListSet[A]]

    Partitions elements in fixed size immutable list sets.

  71. def hasDefiniteSize: Boolean

    Tests whether this immutable list set is known to have a finite size.

  72. def hashCode(): Int

    Returns a hash code value for the object.

  73. def head: A

    Selects the first element of this immutable list set.

  74. def headOption: Option[A]

    Optionally selects the first element.

  75. def init: ListSet[A]

    Selects all elements except the last.

  76. def intersect(that: Set[A]): ListSet[A]

    Computes the intersection between this set and another set.

  77. def isEmpty: Boolean

    Checks if this set is empty.

  78. def isInstanceOf[T0]: Boolean

    This method is used to test whether the dynamic type of the receiver object is T0.

  79. def isTraversableAgain: Boolean

    Tests whether this immutable list set can be repeatedly traversed.

  80. def iterator: Iterator[A]

    Creates a new iterator over all elements contained in this set.

  81. def last: A

    Selects the last element.

  82. def lastOption: Option[A]

    Optionally selects the last element.

  83. def map[B](f: (A) ⇒ B): Traversable[B]

    [use case] Builds a new collection by applying a function to all elements of this immutable list set.

  84. def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[ListSet[A], B, That]): That

    Builds a new collection by applying a function to all elements of this immutable list set.

  85. def max: A

    [use case] Finds the largest element.

  86. def max[B >: A](implicit cmp: Ordering[B]): A

    Finds the largest element.

  87. def min: A

    [use case] Finds the smallest element.

  88. def min[B >: A](implicit cmp: Ordering[B]): A

    Finds the smallest element.

  89. def mkString: String

    Displays all elements of this immutable list set in a string.

  90. def mkString(sep: String): String

    Displays all elements of this immutable list set in a string using a separator string.

  91. def mkString(start: String, sep: String, end: String): String

    Displays all elements of this immutable list set in a string using start, end, and separator strings.

  92. def ne(arg0: AnyRef): Boolean

    o.ne(arg0) is the same as !(o.eq(arg0)).

  93. def newBuilder: Builder[A, ListSet[A]]

    A common implementation of newBuilder for all sets in terms of empty.

  94. def next: ListSet[A]

    no summary matey

  95. def nonEmpty: Boolean

    Tests whether the immutable list set is not empty.

  96. def notify(): Unit

    Wakes up a single thread that is waiting on the receiver object's monitor.

  97. def notifyAll(): Unit

    Wakes up all threads that are waiting on the receiver object's monitor.

  98. def partition(p: (A) ⇒ Boolean): (ListSet[A], ListSet[A])

    Partitions this immutable list set in two immutable list sets according to a predicate.

  99. def product: Int

    [use case] Multiplies up the elements of this collection.

  100. def product[B >: A](implicit num: Numeric[B]): B

    Multiplies up the elements of this collection.

  101. def projection: IterableView[A, ListSet[A]]

    returns a projection that can be used to call non-strict filter,map, and flatMap methods that build projections of the collection.

  102. def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Applies a binary operator to all elements of this immutable list set, going left to right.

  103. def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this immutable list set, going left to right.

  104. def reduceRight[B >: A](op: (A, B) ⇒ B): B

    Applies a binary operator to all elements of this immutable list set, going right to left.

  105. def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this immutable list set, going right to left.

  106. def repr: ListSet[A]

    The collection of type immutable list set underlying this TraversableLike object.

  107. def reversed: List[A]

  108. def sameElements(that: Iterable[A]): Boolean

    [use case] Checks if the other iterable collection contains the same elements in the same order as this immutable list set.

  109. def sameElements[B >: A](that: Iterable[B]): Boolean

    Checks if the other iterable collection contains the same elements in the same order as this immutable list set.

  110. def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[ListSet[A], B, That]): That

    Produces a collection containing cummulative results of applying the operator going left to right.

  111. def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[ListSet[A], B, That]): That

    Produces a collection containing cummulative results of applying the operator going right to left.

  112. def size: Int

    Returns the number of elements in this set.

  113. def slice(from: Int, until: Int): ListSet[A]

    Selects an interval of elements.

  114. def sliding[B >: A](size: Int, step: Int): Iterator[ListSet[A]]

  115. def sliding[B >: A](size: Int): Iterator[ListSet[A]]

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.

  116. def span(p: (A) ⇒ Boolean): (ListSet[A], ListSet[A])

    Splits this immutable list set into a prefix/suffix pair according to a predicate.

  117. def splitAt(n: Int): (ListSet[A], ListSet[A])

    Splits this immutable list set into two at a given position.

  118. def stringPrefix: String

    Defines the prefix of this object's toString representation.

  119. def subsetOf(that: Set[A]): Boolean

    Tests whether this set is a subset of another set.

  120. def sum: Int

    [use case] Sums up the elements of this collection.

  121. def sum[B >: A](implicit num: Numeric[B]): B

    Sums up the elements of this collection.

  122. def synchronized[T0](arg0: T0): T0

  123. def tail: ListSet[A]

    Selects all elements except the first.

  124. def take(n: Int): ListSet[A]

    Selects first n elements.

  125. def takeRight(n: Int): ListSet[A]

    Selects last n elements.

  126. def takeWhile(p: (A) ⇒ Boolean): ListSet[A]

    Takes longest prefix of elements that satisfy a predicate.

  127. def thisCollection: Iterable[A]

    The underlying collection seen as an instance of immutable.ListSet.

  128. def toArray: Array[A]

    [use case] Converts this immutable list set to an array.

  129. def toArray[B >: A](implicit arg0: ClassManifest[B]): Array[B]

    Converts this immutable list set to an array.

  130. def toBuffer[B >: A]: Buffer[B]

    Converts this immutable list set to a mutable buffer.

  131. def toCollection(repr: ListSet[A]): Iterable[A]

    A conversion from collections of type Repr to immutable.ListSet objects.

  132. def toIndexedSeq[B >: A]: IndexedSeq[B]

    Converts this immutable list set to an indexed sequence.

  133. def toIterable: Iterable[A]

    Converts this immutable list set to an iterable collection.

  134. def toIterator: Iterator[A]

    Returns an Iterator over the elements in this immutable list set.

  135. def toList: List[A]

    Converts this immutable list set to a list.

  136. def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]

    Converts this immutable list set to a map.

  137. def toSeq: Seq[A]

    Converts this immutable list set to a sequence.

  138. def toSet[B >: A]: Set[B]

    Converts this immutable list set to a set.

  139. def toStream: Stream[A]

    Converts this immutable list set to a stream.

  140. def toString(): String

    Converts this immutable list set to a string.

  141. def toTraversable: Traversable[A]

    Converts this immutable list set to an unspecified Traversable.

  142. def transpose[B](implicit asTraversable: (A) ⇒ Traversable[B]): ListSet[ListSet[B]]

    Transposes this immutable list set of traversable collections into a immutable list set of immutable list sets.

  143. def union(that: Set[A]): ListSet[A]

    Computes the union between of set and another set.

  144. def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (ListSet[A1], ListSet[A2])

    Converts this immutable list set of pairs into two collections of the first and second halfs of each pair.

  145. def view(from: Int, until: Int): IterableView[A, ListSet[A]]

    Creates a non-strict view of a slice of this immutable list set.

  146. def view: IterableView[A, ListSet[A]]

    Creates a non-strict view of this immutable list set.

  147. def wait(): Unit

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

  149. def wait(arg0: Long): Unit

  150. def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, ListSet[A]]

    Creates a non-strict filter of this immutable list set.

  151. def zip[B](that: Iterable[B]): Iterable[(A, B)]

    [use case] Returns a immutable list set formed from this immutable list set and another iterable collection by combining corresponding elements in pairs.

  152. def zip[A1 >: A, B, That](that: Iterable[B])(implicit bf: CanBuildFrom[ListSet[A], (A1, B), That]): That

    Returns a immutable list set formed from this immutable list set and another iterable collection by combining corresponding elements in pairs.

  153. def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): Iterable[(A, B)]

    [use case] Returns a immutable list set formed from this immutable list set and another iterable collection by combining corresponding elements in pairs.

  154. def zipAll[B, A1 >: A, That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[ListSet[A], (A1, B), That]): That

    Returns a immutable list set formed from this immutable list set and another iterable collection by combining corresponding elements in pairs.

  155. def zipWithIndex: Iterable[(A, Int)]

    [use case] Zips this immutable list set with its indices.

  156. def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[ListSet[A], (A1, Int), That]): That

    Zips this immutable list set with its indices.

  157. def |(that: Set[A]): ListSet[A]

    Computes the union between this set and another set.