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

class KeySet extends AbstractSet[K] with GenKeySet with DefaultSerializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. KeySet
2. DefaultSerializable
3. Serializable
4. GenKeySet
5. AbstractSet
6. Set
7. Equals
8. SetOps
9. Function1
10. AbstractIterable
11. Iterable
12. IterableFactoryDefaults
13. IterableOps
14. IterableOnceOps
15. IterableOnce
16. AnyRef
17. 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 KeySet()

Value Members

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

Deprecated Value Members

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

Ungrouped