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

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

trait SetLike[A, +This <: SetLike[A, This] with Set[A]] extends collection.SetLike[A, This] with Scriptable[A] with Builder[A, This] with Growable[A] with Shrinkable[A] with Cloneable[Set[A]] with Parallelizable[A, ParSet[A]]

 

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