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.15/scala/collection/immutable/Map.html below:

Scala Standard Library 2.12.15 - scala.collection.immutable.Map

trait Map[K, +V] extends Iterable[(K, V)] with collection.Map[K, V] with MapLike[K, V, Map[K, V]]

 

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

Inherited from (K) ⇒ V

Inherited by implicit conversion MonadOps from Map[K, V] to MonadOps[(K, V)] Inherited by implicit conversion Ensuring from Map[K, V] to Ensuring[Map[K, V]] Inherited by implicit conversion ArrowAssoc from Map[K, V] to ArrowAssoc[Map[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