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

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

trait MapLike[K, +V, +This <: MapLike[K, V, This] with Map[K, V]] extends collection.MapLike[K, V, This] with Parallelizable[(K, V), ParMap[K, V]]

 

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

Inherited from (K) ⇒ V

Inherited by implicit conversion MonadOps from MapLike[K, V, This] to MonadOps[(K, V)]

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