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