HashMap

final def !=(arg0: Any): Boolean

final def ##(): Int

def +[B >: A, U >: T](key: B, value: U): HashMap[B, U]

Returns a copy of this map that associates the given value with the given key.

def ++[B >: A](those: Traverser[B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

macro def ++[B >: A, U >: T](those: Map[B, U])(implicit builder: Builder[B] with From[Map[_, _]]): (builder)#State

macro def ++[B >: A](those: Container[B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

def ++[B >: A](those: Collection[B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

def -(key: A): HashMap[A, T]

Returns a copy of this map that associates nothing with the given key.

final def ==(arg0: Any): Boolean

def apply(key: A): T

final def asInstanceOf[T0]: T0

def canEqual(other: Any): Boolean

def choose[B](q: PartialFunction[(A, T), B]): Maybe[B]

macro def choose[B](q: PartialFunction[(A, T), B]): Maybe[B]

macro def choose[B](q: PartialFunction[(A, T), B]): Maybe[B]

def choose[B](q: PartialFunction[(A, T), B]): Maybe[B]

def clone(): AnyRef

def collect[B](q: PartialFunction[(A, T), B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

macro def collect[B](q: PartialFunction[(A, T), B])(implicit builder: Builder[B] with From[Map[_, _]]): (builder)#State

macro def collect[B](q: PartialFunction[(A, T), B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

def collect[B](q: PartialFunction[(A, T), B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

def contains(key: A): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def finalize(): Unit

def flatMap[B](f: ((A, T)) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

macro def flatMap[B](f: ((A, T)) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Map[_, _]]): (builder)#State

macro def flatMap[B](f: ((A, T)) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

def flatMap[B](f: ((A, T)) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

macro def fold[B >: (A, T)](z: B)(op: (B, B) ⇒ B): B

macro def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

def foldLeft[B](z: B)(op: (B, (A, T)) ⇒ B): B

macro def foldLeft[B](z: B)(op: (B, (A, T)) ⇒ B): B

macro def foldLeft[B](z: B)(op: (B, (A, T)) ⇒ B): B

def foldLeft[B](z: B)(op: (B, (A, T)) ⇒ B): B

def foreach[U](f: ((A, T)) ⇒ U): Unit

macro def foreach[U](f: ((A, T)) ⇒ U): Unit

macro def foreach[U](f: ((A, T)) ⇒ U): Unit

def foreach[U](f: ((A, T)) ⇒ U): Unit

def get(key: A): Maybe[T]

final def getClass(): Class[_]

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[(A, T)]

def keys: Set[A]

Returns the set of keys with associations in this map.

def map[B](f: ((A, T)) ⇒ B)(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

macro def map[B](f: ((A, T)) ⇒ B)(implicit builder: Builder[B] with From[Map[_, _]]): (builder)#State

macro def map[B](f: ((A, T)) ⇒ B)(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

def map[B](f: ((A, T)) ⇒ B)(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

macro def mayReduce[B >: (A, T)](op: (B, B) ⇒ B): Maybe[B]

macro def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

def mayReduceLeft[B >: A](op: (B, (A, T)) ⇒ B): Maybe[B]

macro def mayReduceLeft[B >: (A, T)](op: (B, (A, T)) ⇒ B): Maybe[B]

macro def mayReduceLeft[B >: A](op: (B, (A, T)) ⇒ B): Maybe[B]

def mayReduceLeft[B >: A](op: (B, (A, T)) ⇒ B): Maybe[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduce[B >: A](op: (B, B) ⇒ B): B

macro def reduce[B >: (A, T)](op: (B, B) ⇒ B): B

macro def reduce[B >: A](op: (B, B) ⇒ B): B

def reduce[B >: A](op: (B, B) ⇒ B): B

def reduceLeft[B >: A](op: (B, (A, T)) ⇒ B): B

macro def reduceLeft[B >: (A, T)](op: (B, (A, T)) ⇒ B): B

macro def reduceLeft[B >: A](op: (B, (A, T)) ⇒ B): B

def reduceLeft[B >: A](op: (B, (A, T)) ⇒ B): B

def size: Int

def stringPrefix: String

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

def toString(): String

def traverse(f: ((A, T)) ⇒ Unit): Unit

def traverse(f: (A, T) ⇒ Unit): Unit

def values: Container[T]

Returns the associated values in this map.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

macro def zip[B](those: Container[B])(implicit builder: Builder[((A, T), B)] with From[Container[_]]): (builder)#State

def count(p: ((A, T)) ⇒ Boolean): Int

macro def count(p: ((A, T)) ⇒ Boolean): Int

macro def count(p: ((A, T)) ⇒ Boolean): Int

def count(p: ((A, T)) ⇒ Boolean): Int

def drop(lower: Int)(implicit builder: Builder[(A, T)] with From[Traverser[_]]): (builder)#State

macro def drop(lower: Int)(implicit builder: Builder[(A, T)] with From[Map[_, _]]): (builder)#State

macro def drop(lower: Int)(implicit builder: Builder[(A, T)] with From[Container[_]]): (builder)#State

def drop(lower: Int)(implicit builder: Builder[(A, T)] with From[Collection[_]]): (builder)#State

def dropWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Traverser[_]]): (builder)#State

macro def dropWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Map[_, _]]): (builder)#State

macro def dropWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Container[_]]): (builder)#State

def dropWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Collection[_]]): (builder)#State

def eagerly: StrictTraverserOps[(A, T), Traverser[_]]

macro def eagerly: StrictMapOps[A, T, Map[_, _]]

macro def eagerly: StrictContainerOps[(A, T), Container[_]]

def eagerly: StrictCollectionOps[(A, T), Collection[_]]

def exists(p: ((A, T)) ⇒ Boolean): Boolean

macro def exists(p: ((A, T)) ⇒ Boolean): Boolean

macro def exists(p: ((A, T)) ⇒ Boolean): Boolean

def exists(p: ((A, T)) ⇒ Boolean): Boolean

def filter(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Traverser[_]]): (builder)#State

macro def filter(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Map[_, _]]): (builder)#State

macro def filter(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Container[_]]): (builder)#State

def filter(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Collection[_]]): (builder)#State

def find(p: ((A, T)) ⇒ Boolean): Maybe[(A, T)]

macro def find(p: ((A, T)) ⇒ Boolean): Maybe[(A, T)]

macro def find(p: ((A, T)) ⇒ Boolean): Maybe[(A, T)]

def find(p: ((A, T)) ⇒ Boolean): Maybe[(A, T)]

def forall(p: ((A, T)) ⇒ Boolean): Boolean

macro def forall(p: ((A, T)) ⇒ Boolean): Boolean

macro def forall(p: ((A, T)) ⇒ Boolean): Boolean

def forall(p: ((A, T)) ⇒ Boolean): Boolean

def lazily: NonStrictTraverserOps[(A, T)]

macro def lazily: NonStrictMapOps[A, T]

macro def lazily: NonStrictContainerOps[(A, T)]

def lazily: NonStrictCollectionOps[(A, T)]

def slice(lower: Int, upper: Int)(implicit builder: Builder[(A, T)] with From[Traverser[_]]): (builder)#State

macro def slice(lower: Int, upper: Int)(implicit builder: Builder[(A, T)] with From[Map[_, _]]): (builder)#State

macro def slice(lower: Int, upper: Int)(implicit builder: Builder[(A, T)] with From[Container[_]]): (builder)#State

def slice(lower: Int, upper: Int)(implicit builder: Builder[(A, T)] with From[Collection[_]]): (builder)#State

def span(p: ((A, T)) ⇒ Boolean)(implicit builder1: Builder[(A, T)] with From[Traverser[_]], builder2: Builder[(A, T)] with From[Traverser[_]]): ((builder1)#State, (builder2)#State)

macro def span(p: ((A, T)) ⇒ Boolean)(implicit builder1: Builder[(A, T)] with From[Map[_, _]], builder2: Builder[(A, T)] with From[Map[_, _]]): ((builder1)#State, (builder2)#State)

macro def span(p: ((A, T)) ⇒ Boolean)(implicit builder1: Builder[(A, T)] with From[Container[_]], builder2: Builder[(A, T)] with From[Container[_]]): ((builder1)#State, (builder2)#State)

def span(p: ((A, T)) ⇒ Boolean)(implicit builder1: Builder[(A, T)] with From[Collection[_]], builder2: Builder[(A, T)] with From[Collection[_]]): ((builder1)#State, (builder2)#State)

def take(upper: Int)(implicit builder: Builder[(A, T)] with From[Traverser[_]]): (builder)#State

macro def take(upper: Int)(implicit builder: Builder[(A, T)] with From[Map[_, _]]): (builder)#State

macro def take(upper: Int)(implicit builder: Builder[(A, T)] with From[Container[_]]): (builder)#State

def take(upper: Int)(implicit builder: Builder[(A, T)] with From[Collection[_]]): (builder)#State

def takeWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Traverser[_]]): (builder)#State

macro def takeWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Map[_, _]]): (builder)#State

macro def takeWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Container[_]]): (builder)#State

def takeWhile(p: ((A, T)) ⇒ Boolean)(implicit builder: Builder[(A, T)] with From[Collection[_]]): (builder)#State

def withFilter(p: ((A, T)) ⇒ Boolean): Traverser[(A, T)]

def withFilter(p: ((A, T)) ⇒ Boolean): Map[A, T]

def withFilter(p: ((A, T)) ⇒ Boolean): Container[(A, T)]

def withFilter(p: ((A, T)) ⇒ Boolean): Collection[(A, T)]