A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.scala-lang.org/api/2.12.19/scala/collection/mutable/Set.html below:

Scala Standard Library 2.12.19 - scala.collection.mutable.Set

trait Set[A] extends Iterable[A] with collection.Set[A] with GenericSetTemplate[A, Set] with SetLike[A, Set[A]]

 

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Set
  2. SetLike
  3. Cloneable
  4. Cloneable
  5. Cloneable
  6. Shrinkable
  7. Builder
  8. Growable
  9. Clearable
  10. Scriptable
  11. Set
  12. SetLike
  13. Subtractable
  14. GenSet
  15. GenericSetTemplate
  16. GenSetLike
  17. Function1
  18. Iterable
  19. Iterable
  20. IterableLike
  21. Equals
  22. GenIterable
  23. GenIterableLike
  24. Traversable
  25. Mutable
  26. Traversable
  27. GenTraversable
  28. GenericTraversableTemplate
  29. TraversableLike
  30. GenTraversableLike
  31. Parallelizable
  32. TraversableOnce
  33. GenTraversableOnce
  34. FilterMonadic
  35. HasNewBuilder
  36. AnyRef
  37. Any
Implicitly
  1. by CollectionsHaveToParArray
  2. by MonadOps
  3. by any2stringadd
  4. by StringFormat
  5. by Ensuring
  6. by ArrowAssoc
  7. by alternateImplicit
Abstract Value Members
  1.  abstract def +=(elem: A): Set.this.type
  2.  abstract def -=(elem: A): Set.this.type
  3.  abstract def contains(elem: A): Boolean
  4.  abstract def iterator: Iterator[A]
Concrete Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##(): Int
  3.  def &(that: GenSet[A]): Set[A]
  4.  def &~(that: GenSet[A]): Set[A]
  5.  def +(elem1: A, elem2: A, elems: A*): Set[A]
  6.  def +(elem: A): Set[A]
  7.  def ++(xs: GenTraversableOnce[A]): Set[A]
  8.  def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Set[A], B, That]): That
  9.  def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Set[A], B, That]): That
  10.  def ++:[B](that: TraversableOnce[B]): Set[B]
  11.  def ++=(xs: TraversableOnce[A]): Set.this.type
  12.  def +=(elem1: A, elem2: A, elems: A*): Set.this.type
  13.  def -(elem1: A, elem2: A, elems: A*): Set[A]
  14.  def -(elem: A): Set[A]
  15.  def --(xs: GenTraversableOnce[A]): Set[A]
  16.  def --=(xs: TraversableOnce[A]): Set.this.type
  17.  def -=(elem1: A, elem2: A, elems: A*): Set.this.type
  18.  def ->[B](y: B): (Set[A], B)
  19.  final def ==(arg0: Any): Boolean
  20.  def add(elem: A): Boolean
  21.  def addString(b: scala.StringBuilder): scala.StringBuilder
  22.  def addString(b: scala.StringBuilder, sep: String): scala.StringBuilder
  23.  def addString(b: scala.StringBuilder, start: String, sep: String, end: String): scala.StringBuilder
  24.  def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B
  25.  def andThen[A](g: (Boolean) ⇒ A): (A) ⇒ A
  26.  def apply(elem: A): Boolean
  27.  final def asInstanceOf[T0]: T0
  28.  def canEqual(that: Any): Boolean
  29.  def clear(): Unit
  30.  def clone(): Set[A]
  31.  def collect[B](pf: PartialFunction[A, B]): Set[B]
  32.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
  33.  def companion: GenericCompanion[Set]
  34.  def compose[A](g: (A) ⇒ A): (A) ⇒ Boolean
  35.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
  36.  def copyToArray(xs: Array[A]): Unit
  37.  def copyToArray(xs: Array[A], start: Int): Unit
  38.  def copyToBuffer[B >: A](dest: Buffer[B]): Unit
  39.  def count(p: (A) ⇒ Boolean): Int
  40.  def diff(that: GenSet[A]): Set[A]
  41.  def drop(n: Int): Set[A]
  42.  def dropRight(n: Int): Set[A]
  43.  def dropWhile(p: (A) ⇒ Boolean): Set[A]
  44.  def empty: Set[A]
  45.  def ensuring(cond: (Set[A]) ⇒ Boolean, msg: ⇒ Any): Set[A]
  46.  def ensuring(cond: (Set[A]) ⇒ Boolean): Set[A]
  47.  def ensuring(cond: Boolean, msg: ⇒ Any): Set[A]
  48.  def ensuring(cond: Boolean): Set[A]
  49.  final def eq(arg0: AnyRef): Boolean
  50.  def equals(that: Any): Boolean
  51.  def exists(p: (A) ⇒ Boolean): Boolean
  52.  def filter(p: (A) ⇒ Boolean): Set[A]
  53.  def filterNot(p: (A) ⇒ Boolean): Set[A]
  54.  def finalize(): Unit
  55.  def find(p: (A) ⇒ Boolean): Option[A]
  56.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Set[B]
  57.  def flatten[B]: Set[B]
  58.  def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
  59.  def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
  60.  def foldRight[B](z: B)(op: (A, B) ⇒ B): B
  61.  def forall(p: (A) ⇒ Boolean): Boolean
  62.  def foreach(f: (A) ⇒ Unit): Unit
  63.  def genericBuilder[B]: Builder[B, Set[B]]
  64.  final def getClass(): Class[_]
  65.  def groupBy[K](f: (A) ⇒ K): immutable.Map[K, Set[A]]
  66.  def grouped(size: Int): Iterator[Set[A]]
  67.  def hasDefiniteSize: Boolean
  68.  def hashCode(): Int
  69.  def head: A
  70.  def headOption: Option[A]
  71.  def init: Set[A]
  72.  def inits: Iterator[Set[A]]
  73.  def intersect(that: GenSet[A]): Set[A]
  74.  def isEmpty: Boolean
  75.  final def isInstanceOf[T0]: Boolean
  76.  final def isTraversableAgain: Boolean
  77.  def last: A
  78.  def lastOption: Option[A]
  79.  def map[B](f: (A) ⇒ B): Set[B]
  80.  def mapResult[NewTo](f: (Set[A]) ⇒ NewTo): Builder[A, NewTo]
  81.  def max: A
  82.  def maxBy[B](f: (A) ⇒ B): A
  83.  def min: A
  84.  def minBy[B](f: (A) ⇒ B): A
  85.  def mkString: String
  86.  def mkString(sep: String): String
  87.  def mkString(start: String, sep: String, end: String): String
  88.  final def ne(arg0: AnyRef): Boolean
  89.  def newBuilder: Builder[A, Set[A]]
  90.  def nonEmpty: Boolean
  91.  final def notify(): Unit
  92.  final def notifyAll(): Unit
  93.  def par: ParSet[A]
  94.  def parCombiner: Combiner[A, ParSet[A]]
  95.  def partition(p: (A) ⇒ Boolean): (Set[A], Set[A])
  96.  def product: A
  97.  def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
  98.  def reduceLeft[B >: A](op: (B, A) ⇒ B): B
  99.  def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
  100.  def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
  101.  def reduceRight[B >: A](op: (A, B) ⇒ B): B
  102.  def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
  103.  def remove(elem: A): Boolean
  104.  def repr: Set[A]
  105.  def result(): Set[A]
  106.  def retain(p: (A) ⇒ Boolean): Unit
  107.  def reversed: List[A]
  108.  def sameElements(that: GenIterable[A]): Boolean
  109.  def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Set[A], B, That]): That
  110.  def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[Set[A], B, That]): That
  111.  def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[Set[A], B, That]): That
  112.  def seq: Set[A]
  113.  def size: Int
  114.  def sizeHint(coll: TraversableLike[_, _], delta: Int): Unit
  115.  def sizeHint(coll: TraversableLike[_, _]): Unit
  116.  def sizeHint(size: Int): Unit
  117.  def sizeHintBounded(size: Int, boundingColl: TraversableLike[_, _]): Unit
  118.  def sizeHintIfCheap: Int
  119.  def slice(from: Int, until: Int): Set[A]
  120.  def sliding(size: Int, step: Int): Iterator[Set[A]]
  121.  def sliding(size: Int): Iterator[Set[A]]
  122.  def span(p: (A) ⇒ Boolean): (Set[A], Set[A])
  123.  def splitAt(n: Int): (Set[A], Set[A])
  124.  def stringPrefix: String
  125.  def subsetOf(that: GenSet[A]): Boolean
  126.  def subsets(): Iterator[Set[A]]
  127.  def subsets(len: Int): Iterator[Set[A]]
  128.  def sum: A
  129.  final def synchronized[T0](arg0: ⇒ T0): T0
  130.  def tail: Set[A]
  131.  def tails: Iterator[Set[A]]
  132.  def take(n: Int): Set[A]
  133.  def takeRight(n: Int): Set[A]
  134.  def takeWhile(p: (A) ⇒ Boolean): Set[A]
  135.  def thisCollection: collection.Iterable[A]
  136.  def to[Col[_]]: Col[A]
  137.  def toArray: Array[A]
  138.  def toBuffer[A1 >: A]: Buffer[A1]
  139.  def toCollection(repr: Set[A]): collection.Iterable[A]
  140.  def toIndexedSeq: immutable.IndexedSeq[A]
  141.  def toIterable: collection.Iterable[A]
  142.  def toIterator: Iterator[A]
  143.  def toList: List[A]
  144.  def toMap[T, U]: collection.Map[T, U]
  145.  def toParArray: ParArray[T]
  146.  def toSeq: collection.Seq[A]
  147.  def toSet[B >: A]: immutable.Set[B]
  148.  def toStream: immutable.Stream[A]
  149.  def toString(): String
  150.  def toTraversable: collection.Traversable[A]
  151.  def toVector: Vector[A]
  152.  def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Set[Set[B]]
  153.  def union(that: GenSet[A]): Set[A]
  154.  def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Set[A1], Set[A2])
  155.  def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
  156.  def update(elem: A, included: Boolean): Unit
  157.  def view(from: Int, until: Int): IterableView[A, Set[A]]
  158.  def view: IterableView[A, Set[A]]
  159.  final def wait(): Unit
  160.  final def wait(arg0: Long, arg1: Int): Unit
  161.  final def wait(arg0: Long): Unit
  162.  def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, Set[A]]
  163.  def zip[B](that: GenIterable[B]): Set[(A, B)]
  164.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Set[(A, B)]
  165.  def zipWithIndex: Set[(A, Int)]
  166.  def |(that: GenSet[A]): Set[A]
  167.  def →[B](y: B): (Set[A], B)
Deprecated Value Members
  1.  def /:[B](z: B)(op: (B, A) ⇒ B): B
  2.  def :\[B](z: B)(op: (A, B) ⇒ B): B
  3.  def <<(cmd: Message[A]): Unit
  4.  def formatted(fmtstr: String): String

Inherited from java.lang.Cloneable

Inherited from HasNewBuilder[A, scala.collection.mutable.Set[A] @scala.annotation.unchecked.uncheckedVariance] Inherited by implicit conversion MonadOps from Set[A] to MonadOps[A] Inherited by implicit conversion Ensuring from Set[A] to Ensuring[Set[A]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4