Scala Standard Library 2.13.1 - scala.collection.AbstractSet (original) (raw)

abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A]

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. AbstractSet
2. Set
3. Equals
4. SetOps
5. Function1
6. AbstractIterable
7. Iterable
8. IterableFactoryDefaults
9. IterableOps
10. IterableOnceOps
11. IterableOnce
12. AnyRef
13. 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

Instance Constructors

1.  new AbstractSet()

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): (AbstractSet[A], B)
8.  final def ==(arg0: Any): Boolean
9.  final def addString(b: mutable.StringBuilder): mutable.StringBuilder
10.  final def addString(b: mutable.StringBuilder, sep: String): mutable.StringBuilder
11.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder
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: AbstractSet.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: (AbstractSet[A]) => Boolean, msg: => Any): AbstractSet[A]
34.  def ensuring(cond: (AbstractSet[A]) => Boolean): AbstractSet[A]
35.  def ensuring(cond: Boolean, msg: => Any): AbstractSet[A]
36.  def ensuring(cond: Boolean): AbstractSet[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 formatted(fmtstr: String): String
52.  def fromSpecific(coll: IterableOnce[A]): Set[A]
53.  final def getClass(): Class[_ <: AnyRef]
54.  def groupBy[K](f: (A) => K): immutable.Map[K, Set[A]]
55.  def groupMap[K, B](key: (A) => K)(f: (A) => B): immutable.Map[K, Set[B]]
56.  def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): immutable.Map[K, B]
57.  def grouped(size: Int): Iterator[Set[A]]
58.  def hashCode(): Int
59.  def head: A
60.  def headOption: Option[A]
61.  def init: Set[A]
62.  def inits: Iterator[Set[A]]
63.  def intersect(that: Set[A]): Set[A]
64.  def isEmpty: Boolean
65.  final def isInstanceOf[T0]: Boolean
66.  def isTraversableAgain: Boolean
67.  def iterableFactory: IterableFactory[Set]
68.  def knownSize: Int
69.  def last: A
70.  def lastOption: Option[A]
71.  def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, AbstractSet.this.type]
72.  def map[B](f: (A) => B): Set[B]
73.  def max[B >: A](implicit ord: math.Ordering[B]): A
74.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
75.  def maxByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
76.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
77.  def min[B >: A](implicit ord: math.Ordering[B]): A
78.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
79.  def minByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
80.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
81.  final def mkString: String
82.  final def mkString(sep: String): String
83.  final def mkString(start: String, sep: String, end: String): String
84.  final def ne(arg0: AnyRef): Boolean
85.  def newSpecificBuilder: Builder[A, Set[A]]
86.  def nonEmpty: Boolean
87.  final def notify(): Unit
88.  final def notifyAll(): Unit
89.  def partition(p: (A) => Boolean): (Set[A], Set[A])
90.  def partitionMap[A1, A2](f: (A) => Either[A1, A2]): (Set[A1], Set[A2])
91.  def product[B >: A](implicit num: math.Numeric[B]): B
92.  def reduce[B >: A](op: (B, B) => B): B
93.  def reduceLeft[B >: A](op: (B, A) => B): B
94.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
95.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
96.  def reduceRight[B >: A](op: (A, B) => B): B
97.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
98.  def reversed: Iterable[A]
99.  def scan[B >: A](z: B)(op: (B, B) => B): Set[B]
100.  def scanLeft[B](z: B)(op: (B, A) => B): Set[B]
101.  def scanRight[B](z: B)(op: (A, B) => B): Set[B]
102.  def size: Int
103.  def sizeCompare(that: Iterable[_]): Int
104.  def sizeCompare(otherSize: Int): Int
105.  final def sizeIs: SizeCompareOps
106.  def slice(from: Int, until: Int): Set[A]
107.  def sliding(size: Int, step: Int): Iterator[Set[A]]
108.  def sliding(size: Int): Iterator[Set[A]]
109.  def span(p: (A) => Boolean): (Set[A], Set[A])
110.  def splitAt(n: Int): (Set[A], Set[A])
111.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
112.  def stringPrefix: String
113.  def subsetOf(that: Set[A]): Boolean
114.  def subsets(): Iterator[Set[A]]
115.  def subsets(len: Int): Iterator[Set[A]]
116.  def sum[B >: A](implicit num: math.Numeric[B]): B
117.  final def synchronized[T0](arg0: => T0): T0
118.  def tail: Set[A]
119.  def tails: Iterator[Set[A]]
120.  def take(n: Int): Set[A]
121.  def takeRight(n: Int): Set[A]
122.  def takeWhile(p: (A) => Boolean): Set[A]
123.  def tapEach[U](f: (A) => U): Set[A]
124.  def to[C1](factory: Factory[A, C1]): C1
125.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
126.  final def toBuffer[B >: A]: Buffer[B]
127.  def toIndexedSeq: immutable.IndexedSeq[A]
128.  final def toIterable: AbstractSet.this.type
129.  def toList: immutable.List[A]
130.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
131.  def toSeq: immutable.Seq[A]
132.  def toSet[B >: A]: immutable.Set[B]
133.  def toString(): String
134.  def toVector: immutable.Vector[A]
135.  def transpose[B](implicit asIterable: (A) => Iterable[B]): Set[Set[B]]
136.  final def union(that: Set[A]): Set[A]
137.  def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (Set[A1], Set[A2])
138.  def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
139.  def view: View[A]
140.  final def wait(): Unit
141.  final def wait(arg0: Long, arg1: Int): Unit
142.  final def wait(arg0: Long): Unit
143.  def withFilter(p: (A) => Boolean): WithFilter[A, [_]Set[_]]
144.  def zip[B](that: IterableOnce[B]): Set[(A, B)]
145.  def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Set[(A1, B)]
146.  def zipWithIndex: Set[(A, Int)]
147.  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 hasDefiniteSize: Boolean
27.  def isEmpty: Boolean
28.  def map[B](f: (A) => B): IterableOnce[B]
29.  def max(implicit ord: math.Ordering[A]): A
30.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
31.  def min(implicit ord: math.Ordering[A]): A
32.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
33.  def mkString: String
34.  def mkString(sep: String): String
35.  def mkString(start: String, sep: String, end: String): String
36.  def nonEmpty: Boolean
37.  def product(implicit num: math.Numeric[A]): A
38.  def reduce(f: (A, A) => A): A
39.  def reduceLeft(f: (A, A) => A): A
40.  def reduceLeftOption(f: (A, A) => A): Option[A]
41.  def reduceOption(f: (A, A) => A): Option[A]
42.  def reduceRight(f: (A, A) => A): A
43.  def reduceRightOption(f: (A, A) => A): Option[A]
44.  final def repr: Set[A]
45.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
46.  def seq: AbstractSet.this.type
47.  def size: Int
48.  def sum(implicit num: math.Numeric[A]): A
49.  def to[C1](factory: Factory[A, C1]): C1
50.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
51.  def toBuffer[B >: A]: Buffer[B]
52.  def toIndexedSeq: IndexedSeq[A]
53.  final def toIterable: Iterable[A]
54.  def toIterator: Iterator[A]
55.  final def toIterator: Iterator[A]
56.  def toList: immutable.List[A]
57.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
58.  def toSeq: immutable.Seq[A]
59.  def toSet[B >: A]: immutable.Set[B]
60.  def toStream: immutable.Stream[A]
61.  final def toStream: immutable.Stream[A]
62.  final def toTraversable: Traversable[A]
63.  final def toTraversable: Traversable[A]
64.  def toVector: immutable.Vector[A]
65.  def view(from: Int, until: Int): View[A]
66.  def withFilter(f: (A) => Boolean): Iterator[A]
67.  def →[B](y: B): (AbstractSet[A], B)

Ungrouped