Scala Standard Library 2.13.1 - scala.collection.MapOps (original) (raw)
trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, collection.AnyConstr, _], +C] extends IterableOps[(K, V), Iterable, C] with PartialFunction[K, V]
Ordering
- Alphabetic
- By Inheritance
Inherited
- MapOps
- PartialFunction
- Function1
- IterableOps
- IterableOnceOps
- IterableOnce
- AnyRef
- Any
Implicitly
by UnliftOps
by iterableOnceExtensionMethods
by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc
Hide All
Show All
Visibility
- Public
- Protected
Abstract Value Members
- abstract def coll: C
- abstract def fromSpecific(coll: IterableOnce[(K, V)]): C
- abstract def get(key: K): Option[V]
- abstract def iterableFactory: IterableFactory[Iterable]
- abstract def iterator: Iterator[(K, V)]
- abstract def mapFactory: MapFactory[CC]
- abstract def newSpecificBuilder: Builder[(K, V), C]
- abstract def toIterable: Iterable[(K, V)]
Concrete Value Members
- final def !=(arg0: Any): Boolean
- final def ##(): Int
- def ++[V2 >: V](xs: IterableOnce[(K, V2)]): CC[K, V2]
- final def ++[B >: (K, V)](suffix: IterableOnce[B]): Iterable[B]
- def ->[B](y: B): (MapOps[K, V, CC, C], B)
- final def ==(arg0: Any): Boolean
- def addString(sb: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder
- final def addString(b: mutable.StringBuilder): mutable.StringBuilder
- final def addString(b: mutable.StringBuilder, sep: String): mutable.StringBuilder
- def andThen[C](k: PartialFunction[V, C]): PartialFunction[K, C]
- def andThen[C](k: (V) => C): PartialFunction[K, C]
- def apply(key: K): V
- def applyOrElse[K1 <: K, V1 >: V](x: K1, default: (K1) => V1): V1
- final def asInstanceOf[T0]: T0
- def clone(): AnyRef
- def collect[K2, V2](pf: PartialFunction[(K, V), (K2, V2)]): CC[K2, V2]
- def collect[B](pf: PartialFunction[(K, V), B]): Iterable[B]
- def collectFirst[B](pf: PartialFunction[(K, V), B]): Option[B]
- def compose[R](k: PartialFunction[R, K]): PartialFunction[R, V]
- def compose[A](g: (A) => K): (A) => V
- def concat[V2 >: V](suffix: IterableOnce[(K, V2)]): CC[K, V2]
- def concat[B >: (K, V)](suffix: IterableOnce[B]): Iterable[B]
- def contains(key: K): Boolean
- def copyToArray[B >: (K, V)](xs: Array[B], start: Int, len: Int): Int
- def copyToArray[B >: (K, V)](xs: Array[B], start: Int): Int
- def copyToArray[B >: (K, V)](xs: Array[B]): Int
- def corresponds[B](that: IterableOnce[B])(p: ((K, V), B) => Boolean): Boolean
- def count(p: ((K, V)) => Boolean): Int
- def default(key: K): V
- def drop(n: Int): C
- def dropRight(n: Int): C
- def dropWhile(p: ((K, V)) => Boolean): C
- def elementWise: ElementWiseExtractor[K, V]
- def empty: C
- def ensuring(cond: (MapOps[K, V, CC, C]) => Boolean, msg: => Any): MapOps[K, V, CC, C]
- def ensuring(cond: (MapOps[K, V, CC, C]) => Boolean): MapOps[K, V, CC, C]
- def ensuring(cond: Boolean, msg: => Any): MapOps[K, V, CC, C]
- def ensuring(cond: Boolean): MapOps[K, V, CC, C]
- final def eq(arg0: AnyRef): Boolean
- def equals(arg0: AnyRef): Boolean
- def exists(p: ((K, V)) => Boolean): Boolean
- def filter(pred: ((K, V)) => Boolean): C
- def filterNot(pred: ((K, V)) => Boolean): C
- def finalize(): Unit
- def find(p: ((K, V)) => Boolean): Option[(K, V)]
- def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]): CC[K2, V2]
- def flatMap[B](f: ((K, V)) => IterableOnce[B]): Iterable[B]
- def flatten[B](implicit asIterable: ((K, V)) => IterableOnce[B]): Iterable[B]
- def fold[A1 >: (K, V)](z: A1)(op: (A1, A1) => A1): A1
- def foldLeft[B](z: B)(op: (B, (K, V)) => B): B
- def foldRight[B](z: B)(op: ((K, V), B) => B): B
- def forall(p: ((K, V)) => Boolean): Boolean
- def foreach[U](f: ((K, V)) => U): Unit
- def foreachEntry[U](f: (K, V) => U): Unit
- def formatted(fmtstr: String): String
- final def getClass(): Class[_ <: AnyRef]
- def getOrElse[V1 >: V](key: K, default: => V1): V1
- def groupBy[K](f: ((K, V)) => K): immutable.Map[K, C]
- def groupMap[K, B](key: ((K, V)) => K)(f: ((K, V)) => B): immutable.Map[K, Iterable[B]]
- def groupMapReduce[K, B](key: ((K, V)) => K)(f: ((K, V)) => B)(reduce: (B, B) => B): immutable.Map[K, B]
- def grouped(size: Int): Iterator[C]
- def hashCode(): Int
- def head: (K, V)
- def headOption: Option[(K, V)]
- def init: C
- def inits: Iterator[C]
- def isDefinedAt(key: K): Boolean
- def isEmpty: Boolean
- final def isInstanceOf[T0]: Boolean
- def isTraversableAgain: Boolean
- def keySet: Set[K]
- def keyStepper[S <: Stepper[_]](implicit shape: StepperShape[K, S]): S
- def keys: Iterable[K]
- def keysIterator: Iterator[K]
- def knownSize: Int
- def last: (K, V)
- def lastOption: Option[(K, V)]
- def lift: (K) => Option[V]
- def map[K2, V2](f: ((K, V)) => (K2, V2)): CC[K2, V2]
- def map[B](f: ((K, V)) => B): Iterable[B]
- final def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]): CC[K2, V2]
- def max[B >: (K, V)](implicit ord: math.Ordering[B]): (K, V)
- def maxBy[B](f: ((K, V)) => B)(implicit cmp: math.Ordering[B]): (K, V)
- def maxByOption[B](f: ((K, V)) => B)(implicit cmp: math.Ordering[B]): Option[(K, V)]
- def maxOption[B >: (K, V)](implicit ord: math.Ordering[B]): Option[(K, V)]
- def min[B >: (K, V)](implicit ord: math.Ordering[B]): (K, V)
- def minBy[B](f: ((K, V)) => B)(implicit cmp: math.Ordering[B]): (K, V)
- def minByOption[B](f: ((K, V)) => B)(implicit cmp: math.Ordering[B]): Option[(K, V)]
- def minOption[B >: (K, V)](implicit ord: math.Ordering[B]): Option[(K, V)]
- final def mkString: String
- final def mkString(sep: String): String
- final def mkString(start: String, sep: String, end: String): String
- final def ne(arg0: AnyRef): Boolean
- def nonEmpty: Boolean
- final def notify(): Unit
- final def notifyAll(): Unit
- def orElse[A1 <: K, B1 >: V](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
- def partition(p: ((K, V)) => Boolean): (C, C)
- def partitionMap[A1, A2](f: ((K, V)) => Either[A1, A2]): (Iterable[A1], Iterable[A2])
- def product[B >: (K, V)](implicit num: math.Numeric[B]): B
- def reduce[B >: (K, V)](op: (B, B) => B): B
- def reduceLeft[B >: (K, V)](op: (B, (K, V)) => B): B
- def reduceLeftOption[B >: (K, V)](op: (B, (K, V)) => B): Option[B]
- def reduceOption[B >: (K, V)](op: (B, B) => B): Option[B]
- def reduceRight[B >: (K, V)](op: ((K, V), B) => B): B
- def reduceRightOption[B >: (K, V)](op: ((K, V), B) => B): Option[B]
- def reversed: Iterable[(K, V)]
- def runWith[U](action: (V) => U): (K) => Boolean
- def scan[B >: (K, V)](z: B)(op: (B, B) => B): Iterable[B]
- def scanLeft[B](z: B)(op: (B, (K, V)) => B): Iterable[B]
- def scanRight[B](z: B)(op: ((K, V), B) => B): Iterable[B]
- def size: Int
- def sizeCompare(that: Iterable[_]): Int
- def sizeCompare(otherSize: Int): Int
- final def sizeIs: SizeCompareOps
- def slice(from: Int, until: Int): C
- def sliding(size: Int, step: Int): Iterator[C]
- def sliding(size: Int): Iterator[C]
- def span(p: ((K, V)) => Boolean): (C, C)
- def splitAt(n: Int): (C, C)
- def stepper[S <: Stepper[_]](implicit shape: StepperShape[(K, V), S]): S
- def sum[B >: (K, V)](implicit num: math.Numeric[B]): B
- final def synchronized[T0](arg0: => T0): T0
- def tail: C
- def tails: Iterator[C]
- def take(n: Int): C
- def takeRight(n: Int): C
- def takeWhile(p: ((K, V)) => Boolean): C
- def tapEach[U](f: ((K, V)) => U): C
- def to[C1](factory: Factory[(K, V), C1]): C1
- def toArray[B >: (K, V)](implicit arg0: ClassTag[B]): Array[B]
- final def toBuffer[B >: (K, V)]: Buffer[B]
- def toIndexedSeq: immutable.IndexedSeq[(K, V)]
- def toList: immutable.List[(K, V)]
- def toMap[K, V](implicit ev: <:<[(K, V), (K, V)]): immutable.Map[K, V]
- def toSeq: immutable.Seq[(K, V)]
- def toSet[B >: (K, V)]: immutable.Set[B]
- def toString(): String
- def toVector: immutable.Vector[(K, V)]
- def transpose[B](implicit asIterable: ((K, V)) => Iterable[B]): Iterable[Iterable[B]]
- def unapply(a: K): Option[V]
- def unlift: PartialFunction[K, B]
- def unzip[A1, A2](implicit asPair: ((K, V)) => (A1, A2)): (Iterable[A1], Iterable[A2])
- def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
- def valueStepper[S <: Stepper[_]](implicit shape: StepperShape[V, S]): S
- def values: Iterable[V]
- def valuesIterator: Iterator[V]
- def view: MapView[K, V]
- final def wait(): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- final def wait(arg0: Long): Unit
- def withFilter(p: ((K, V)) => Boolean): WithFilter[(K, V), Iterable]
- def zip[B](that: IterableOnce[B]): Iterable[((K, V), B)]
- def zipAll[A1 >: (K, V), B](that: Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]
- def zipWithIndex: Iterable[((K, V), Int)]
Deprecated Value Members
- def +[V1 >: V](elem1: (K, V1), elem2: (K, V1), elems: (K, V1)*): CC[K, V1]
- def +[V1 >: V](kv: (K, V1)): CC[K, V1]
- def ++:[V1 >: V](that: IterableOnce[(K, V1)]): CC[K, V1]
- def ++:[B >: (K, V)](that: IterableOnce[B]): Iterable[B]
- def --(keys: IterableOnce[K]): C
- def /:[B](z: B)(op: (B, (K, V)) => B): B
- final def /:[B](z: B)(op: (B, (K, V)) => B): B
- def :\[B](z: B)(op: ((K, V), B) => B): B
- final def :\[B](z: B)(op: ((K, V), B) => B): B
- def aggregate[B](z: => B)(seqop: (B, (K, V)) => B, combop: (B, B) => B): B
- def collectFirst[B](f: PartialFunction[(K, V), B]): Option[B]
- def companion: IterableFactory[Iterable]
- def copyToBuffer(dest: Buffer[(K, V)]): Unit
- final def copyToBuffer[B >: (K, V)](dest: Buffer[B]): Unit
- def count(f: ((K, V)) => Boolean): Int
- def exists(f: ((K, V)) => Boolean): Boolean
- def filter(f: ((K, V)) => Boolean): Iterator[(K, V)]
- def filterKeys(p: (K) => Boolean): MapView[K, V]
- def find(p: ((K, V)) => Boolean): Option[(K, V)]
- def flatMap[B](f: ((K, V)) => IterableOnce[B]): IterableOnce[B]
- def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
- def foldLeft[B](z: B)(op: (B, (K, V)) => B): B
- def foldRight[B](z: B)(op: ((K, V), B) => B): B
- def forall(f: ((K, V)) => Boolean): Boolean
- def foreach[U](f: ((K, V)) => U): Unit
- def hasDefiniteSize: Boolean
- def isEmpty: Boolean
- def map[B](f: ((K, V)) => B): IterableOnce[B]
- def mapValues[W](f: (V) => W): MapView[K, W]
- def max(implicit ord: math.Ordering[(K, V)]): (K, V)
- def maxBy[B](f: ((K, V)) => B)(implicit cmp: math.Ordering[B]): (K, V)
- def min(implicit ord: math.Ordering[(K, V)]): (K, V)
- def minBy[B](f: ((K, V)) => B)(implicit cmp: math.Ordering[B]): (K, V)
- def mkString: String
- def mkString(sep: String): String
- def mkString(start: String, sep: String, end: String): String
- def nonEmpty: Boolean
- def product(implicit num: math.Numeric[(K, V)]): (K, V)
- def reduce(f: ((K, V), (K, V)) => (K, V)): (K, V)
- def reduceLeft(f: ((K, V), (K, V)) => (K, V)): (K, V)
- def reduceLeftOption(f: ((K, V), (K, V)) => (K, V)): Option[(K, V)]
- def reduceOption(f: ((K, V), (K, V)) => (K, V)): Option[(K, V)]
- def reduceRight(f: ((K, V), (K, V)) => (K, V)): (K, V)
- def reduceRightOption(f: ((K, V), (K, V)) => (K, V)): Option[(K, V)]
- final def repr: C
- def sameElements[B >: A](that: IterableOnce[B]): Boolean
- def size: Int
- def sum(implicit num: math.Numeric[(K, V)]): (K, V)
- def to[C1](factory: Factory[(K, V), C1]): C1
- def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
- def toBuffer[B >: A]: Buffer[B]
- def toIndexedSeq: IndexedSeq[(K, V)]
- final def toIterable: Iterable[(K, V)]
- def toIterator: Iterator[(K, V)]
- final def toIterator: Iterator[(K, V)]
- def toList: immutable.List[(K, V)]
- def toMap[K, V](implicit ev: <:<[(K, V), (K, V)]): immutable.Map[K, V]
- def toSeq: immutable.Seq[(K, V)]
- def toSet[B >: A]: immutable.Set[B]
- def toStream: immutable.Stream[(K, V)]
- final def toStream: immutable.Stream[(K, V)]
- final def toTraversable: Traversable[(K, V)]
- final def toTraversable: Traversable[(K, V)]
- def toVector: immutable.Vector[(K, V)]
- def view(from: Int, until: Int): View[(K, V)]
- def withFilter(f: ((K, V)) => Boolean): Iterator[(K, V)]
- def →[B](y: B): (MapOps[K, V, CC, C], B)