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/immutable/Set.html below:

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

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

 

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