Scala Standard Library 2.13.15 - scala.collection.Set (original) (raw)

trait Set[A] extends Iterable[A] with SetOps[A, Set, Set[A]] with Equals with IterableFactoryDefaults[A, Set]

Ordering

  1. Alphabetic
  2. By Inheritance

Inherited

  1. Set
  2. Equals
  3. SetOps
  4. Function1
  5. Iterable
  6. IterableFactoryDefaults
  7. IterableOps
  8. IterableOnceOps
  9. IterableOnce
  10. AnyRef
  11. Any

Implicitly

  1. by iterableOnceExtensionMethods

  2. by any2stringadd

  3. by StringFormat

  4. by Ensuring

  5. by ArrowAssoc

  6. Hide All

  7. Show All

Visibility

  1. Public
  2. Protected

Abstract Value Members

  1. abstract def contains(elem: A): Boolean
  2. abstract def diff(that: Set[A]): Set[A]
  3. abstract def iterator: Iterator[A]

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
  2. final def ##: Int
  3. final def &(that: Set[A]): Set[A]
  4. final def &~(that: Set[A]): Set[A]
  5. final def ++(that: IterableOnce[A]): Set[A]
  6. final def ++[B >: A](suffix: IterableOnce[B]): Set[B]
  7. def ->[B](y: B): (Set[A], B)
  8. final def ==(arg0: Any): Boolean
  9. final def addString(b: mutable.StringBuilder): b.type
  10. final def addString(b: mutable.StringBuilder, sep: String): b.type
  11. def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): b.type
  12. def andThen[A](g: (Boolean) => A): (A) => A
  13. final def apply(elem: A): Boolean
  14. final def asInstanceOf[T0]: T0
  15. def canEqual(that: Any): Boolean
  16. def className: String
  17. def clone(): AnyRef
  18. final def coll: Set.this.type
  19. def collect[B](pf: PartialFunction[A, B]): Set[B]
  20. def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
  21. def compose[A](g: (A) => A): (A) => Boolean
  22. def concat(that: IterableOnce[A]): Set[A]
  23. def concat[B >: A](suffix: IterableOnce[B]): Set[B]
  24. def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
  25. def copyToArray[B >: A](xs: Array[B], start: Int): Int
  26. def copyToArray[B >: A](xs: Array[B]): Int
  27. def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean
  28. def count(p: (A) => Boolean): Int
  29. def drop(n: Int): Set[A]
  30. def dropRight(n: Int): Set[A]
  31. def dropWhile(p: (A) => Boolean): Set[A]
  32. def empty: Set[A]
  33. def ensuring(cond: (Set[A]) => Boolean, msg: => Any): Set[A]
  34. def ensuring(cond: (Set[A]) => Boolean): Set[A]
  35. def ensuring(cond: Boolean, msg: => Any): Set[A]
  36. def ensuring(cond: Boolean): Set[A]
  37. final def eq(arg0: AnyRef): Boolean
  38. def equals(that: Any): Boolean
  39. def exists(p: (A) => Boolean): Boolean
  40. def filter(pred: (A) => Boolean): Set[A]
  41. def filterNot(pred: (A) => Boolean): Set[A]
  42. def finalize(): Unit
  43. def find(p: (A) => Boolean): Option[A]
  44. def flatMap[B](f: (A) => IterableOnce[B]): Set[B]
  45. def flatten[B](implicit asIterable: (A) => IterableOnce[B]): Set[B]
  46. def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  47. def foldLeft[B](z: B)(op: (B, A) => B): B
  48. def foldRight[B](z: B)(op: (A, B) => B): B
  49. def forall(p: (A) => Boolean): Boolean
  50. def foreach[U](f: (A) => U): Unit
  51. def fromSpecific(coll: IterableOnce[A]): Set[A]
  52. final def getClass(): Class[_ <: AnyRef]
  53. def groupBy[K](f: (A) => K): immutable.Map[K, Set[A]]
  54. def groupMap[K, B](key: (A) => K)(f: (A) => B): immutable.Map[K, Set[B]]
  55. def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): immutable.Map[K, B]
  56. def grouped(size: Int): Iterator[Set[A]]
  57. def hashCode(): Int
  58. def head: A
  59. def headOption: Option[A]
  60. def init: Set[A]
  61. def inits: Iterator[Set[A]]
  62. def intersect(that: Set[A]): Set[A]
  63. def isEmpty: Boolean
  64. final def isInstanceOf[T0]: Boolean
  65. def isTraversableAgain: Boolean
  66. def iterableFactory: IterableFactory[Set]
  67. def knownSize: Int
  68. def last: A
  69. def lastOption: Option[A]
  70. def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Set.this.type]
  71. def map[B](f: (A) => B): Set[B]
  72. def max[B >: A](implicit ord: math.Ordering[B]): A
  73. def maxBy[B](f: (A) => B)(implicit ord: math.Ordering[B]): A
  74. def maxByOption[B](f: (A) => B)(implicit ord: math.Ordering[B]): Option[A]
  75. def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
  76. def min[B >: A](implicit ord: math.Ordering[B]): A
  77. def minBy[B](f: (A) => B)(implicit ord: math.Ordering[B]): A
  78. def minByOption[B](f: (A) => B)(implicit ord: math.Ordering[B]): Option[A]
  79. def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
  80. final def mkString: String
  81. final def mkString(sep: String): String
  82. final def mkString(start: String, sep: String, end: String): String
  83. final def ne(arg0: AnyRef): Boolean
  84. def newSpecificBuilder: Builder[A, Set[A]]
  85. def nonEmpty: Boolean
  86. final def notify(): Unit
  87. final def notifyAll(): Unit
  88. def partition(p: (A) => Boolean): (Set[A], Set[A])
  89. def partitionMap[A1, A2](f: (A) => Either[A1, A2]): (Set[A1], Set[A2])
  90. def product[B >: A](implicit num: math.Numeric[B]): B
  91. def reduce[B >: A](op: (B, B) => B): B
  92. def reduceLeft[B >: A](op: (B, A) => B): B
  93. def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
  94. def reduceOption[B >: A](op: (B, B) => B): Option[B]
  95. def reduceRight[B >: A](op: (A, B) => B): B
  96. def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
  97. def reversed: Iterable[A]
  98. def scan[B >: A](z: B)(op: (B, B) => B): Set[B]
  99. def scanLeft[B](z: B)(op: (B, A) => B): Set[B]
  100. def scanRight[B](z: B)(op: (A, B) => B): Set[B]
  101. def size: Int
  102. def sizeCompare(that: Iterable[_]): Int
  103. def sizeCompare(otherSize: Int): Int
  104. final def sizeIs: SizeCompareOps
  105. def slice(from: Int, until: Int): Set[A]
  106. def sliding(size: Int, step: Int): Iterator[Set[A]]
  107. def sliding(size: Int): Iterator[Set[A]]
  108. def span(p: (A) => Boolean): (Set[A], Set[A])
  109. def splitAt(n: Int): (Set[A], Set[A])
  110. def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
  111. def stringPrefix: String
  112. def subsetOf(that: Set[A]): Boolean
  113. def subsets(): Iterator[Set[A]]
  114. def subsets(len: Int): Iterator[Set[A]]
  115. def sum[B >: A](implicit num: math.Numeric[B]): B
  116. final def synchronized[T0](arg0: => T0): T0
  117. def tail: Set[A]
  118. def tails: Iterator[Set[A]]
  119. def take(n: Int): Set[A]
  120. def takeRight(n: Int): Set[A]
  121. def takeWhile(p: (A) => Boolean): Set[A]
  122. def tapEach[U](f: (A) => U): Set[A]
  123. def to[C1](factory: Factory[A, C1]): C1
  124. def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  125. final def toBuffer[B >: A]: Buffer[B]
  126. def toIndexedSeq: immutable.IndexedSeq[A]
  127. def toList: immutable.List[A]
  128. def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
  129. def toSeq: immutable.Seq[A]
  130. def toSet[B >: A]: immutable.Set[B]
  131. def toString(): String
  132. def toVector: immutable.Vector[A]
  133. def transpose[B](implicit asIterable: (A) => Iterable[B]): Set[Set[B]]
  134. final def union(that: Set[A]): Set[A]
  135. def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (Set[A1], Set[A2])
  136. def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
  137. def view: View[A]
  138. final def wait(): Unit
  139. final def wait(arg0: Long, arg1: Int): Unit
  140. final def wait(arg0: Long): Unit
  141. def withFilter(p: (A) => Boolean): WithFilter[A, [_]Set[_]]
  142. def zip[B](that: IterableOnce[B]): Set[(A, B)]
  143. def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Set[(A1, B)]
  144. def zipWithIndex: Set[(A, Int)]
  145. final def |(that: Set[A]): Set[A]

Deprecated Value Members

  1. def +(elem1: A, elem2: A, elems: A*): Set[A]
  2. def +(elem: A): Set[A]
  3. def ++:[B >: A](that: IterableOnce[B]): Set[B]
  4. def -(elem1: A, elem2: A, elems: A*): Set[A]
  5. def -(elem: A): Set[A]
  6. def --(that: IterableOnce[A]): Set[A]
  7. def /:[B](z: B)(op: (B, A) => B): B
  8. final def /:[B](z: B)(op: (B, A) => B): B
  9. def :\[B](z: B)(op: (A, B) => B): B
  10. final def :\[B](z: B)(op: (A, B) => B): B
  11. def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
  12. def collectFirst[B](f: PartialFunction[A, B]): Option[B]
  13. def companion: IterableFactory[[_]Set[_]]
  14. def copyToBuffer(dest: Buffer[A]): Unit
  15. final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
  16. def count(f: (A) => Boolean): Int
  17. def exists(f: (A) => Boolean): Boolean
  18. def filter(f: (A) => Boolean): Iterator[A]
  19. def find(p: (A) => Boolean): Option[A]
  20. def flatMap[B](f: (A) => IterableOnce[B]): IterableOnce[B]
  21. def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  22. def foldLeft[B](z: B)(op: (B, A) => B): B
  23. def foldRight[B](z: B)(op: (A, B) => B): B
  24. def forall(f: (A) => Boolean): Boolean
  25. def foreach[U](f: (A) => U): Unit
  26. def formatted(fmtstr: String): String
  27. def hasDefiniteSize: Boolean
  28. def isEmpty: Boolean
  29. def map[B](f: (A) => B): IterableOnce[B]
  30. def max(implicit ord: math.Ordering[A]): A
  31. def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
  32. def min(implicit ord: math.Ordering[A]): A
  33. def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
  34. def mkString: String
  35. def mkString(sep: String): String
  36. def mkString(start: String, sep: String, end: String): String
  37. def nonEmpty: Boolean
  38. def product(implicit num: math.Numeric[A]): A
  39. def reduce(f: (A, A) => A): A
  40. def reduceLeft(f: (A, A) => A): A
  41. def reduceLeftOption(f: (A, A) => A): Option[A]
  42. def reduceOption(f: (A, A) => A): Option[A]
  43. def reduceRight(f: (A, A) => A): A
  44. def reduceRightOption(f: (A, A) => A): Option[A]
  45. final def repr: Set[A]
  46. def sameElements[B >: A](that: IterableOnce[B]): Boolean
  47. def seq: Set.this.type
  48. def size: Int
  49. def sum(implicit num: math.Numeric[A]): A
  50. def to[C1](factory: Factory[A, C1]): C1
  51. def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  52. def toBuffer[B >: A]: Buffer[B]
  53. def toIndexedSeq: IndexedSeq[A]
  54. final def toIterable: Iterable[A]
  55. final def toIterable: Set.this.type
  56. def toIterator: Iterator[A]
  57. final def toIterator: Iterator[A]
  58. def toList: immutable.List[A]
  59. def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
  60. def toSeq: immutable.Seq[A]
  61. def toSet[B >: A]: immutable.Set[B]
  62. def toStream: immutable.Stream[A]
  63. final def toStream: immutable.Stream[A]
  64. final def toTraversable: Traversable[A]
  65. final def toTraversable: Traversable[A]
  66. def toVector: immutable.Vector[A]
  67. def view(from: Int, until: Int): View[A]
  68. def withFilter(f: (A) => Boolean): Iterator[A]
  69. def →[B](y: B): (Set[A], B)

Ungrouped