MapSubInstances

abstract def ab_+[K, V](m: XMap[K, V], k: K, v: V)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

How MapLike#updated might be typed in a sane world.

abstract def ab_-[K, V](m: XMap[K, V], k: K)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

As with ab_+, but with MapLike#-.

implicit abstract def buildXMap[K, V, K2, V2](implicit arg0: BuildKeyConstraint[K2]): CanBuildFrom[XMap[K, V], (K2, V2), XMap[K2, V2]]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def alter[K, A](m: XMap[K, A], k: K)(f: (Option[A]) ⇒ Option[A])(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

Vary the value of m get k.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def getOrAdd[F[_], K, A](m: XMap[K, A], k: K)(fa: ⇒ F[A])(implicit F: Applicative[F], K: BuildKeyConstraint[K]): F[(XMap[K, A], A)]

Grab a value out of Map if it's present.

def hashCode(): Int

final def insertWith[K, A](m1: XMap[K, A], k: K, v: A)(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

As with Map.updated, but resolve a collision with f.

final def intersectWith[K, A, B, C](m1: XMap[K, A], m2: XMap[K, B])(f: (A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[K, C]

Collect only elements with matching keys, joining their associated values with f.

final def intersectWithKey[K, A, B, C](m1: XMap[K, A], m2: XMap[K, B])(f: (K, A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[K, C]

Like intersectWith, but tell f about the key.

final def isInstanceOf[T0]: Boolean

implicit def mapEqual[K, V](implicit arg0: Order[K], arg1: Equal[V]): Equal[XMap[K, V]]

implicit def mapFoldable[K]: Foldable[[β$1$]XMap[K, β$1$]]

implicit def mapInstance[K](implicit arg0: BuildKeyConstraint[K]): Traverse[[β$2$]XMap[K, β$2$]] with IsEmpty[[β$3$]XMap[K, β$3$]] with Bind[[β$4$]XMap[K, β$4$]] with Align[[β$5$]XMap[K, β$5$]]

Covariant over the value parameter, where plus applies the Last semigroup to values.

final def mapKeys[K, K2, A](m: XMap[K, A])(f: (K) ⇒ K2)(implicit arg0: BuildKeyConstraint[K2]): XMap[K2, A]

Exchange keys of m according to f.

implicit def mapMonoid[K, V](implicit arg0: BuildKeyConstraint[K], arg1: Semigroup[V]): Monoid[XMap[K, V]]

Map union monoid, unifying values with V's append.

implicit def mapOrder[K, V](implicit arg0: Order[K], arg1: Order[V]): Order[XMap[K, V]]

implicit def mapShow[K, V](implicit K: Show[K], V: Show[V]): Show[XMap[K, V]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def unionWith[K, A](m1: XMap[K, A], m2: XMap[K, A])(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

Union, resolving collisions with f, where the first arg is guaranteed to be from m1, the second from m2.

final def unionWithKey[K, A](m1: XMap[K, A], m2: XMap[K, A])(f: (K, A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

Like unionWith, but telling f about the key.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit