basis.collections

Map

trait Map[+A, +T] extends Equals with Family[Map[_, _]] with Container[(A, T)]

An association of unique keys with values.

Source
Map.scala
Linear Supertypes
Container[(A, T)], Collection[(A, T)], Traverser[(A, T)], basis.Family[Map[_, _]], Equals, Any
Known Subclasses
BaseObject, BsonObject, DeltaObject, FormObject, HashTrieMap, JsonObject, ObjectDelta, ObjectDelta, ObjectDelta, ObjectForm, ObjectForm, ObjectForm, ObjectForm, ObjectForm, ObjectForm, ObjectState, ObjectState, ProtoObject, ProtoObjectDelta, StateObject, Submap
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Map
  2. Container
  3. Collection
  4. Traverser
  5. Family
  6. Equals
  7. Any
Implicitly
  1. by TraverserToGeneralOps
  2. by MapToGeneralOps
  3. by ContainerToGeneralOps
  4. by CollectionToGeneralOps
  5. by TraverserToStrictOps
  6. by MapToStrictOps
  7. by ContainerToStrictOps
  8. by CollectionToStrictOps
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. type Family = Map[_, _]

    Definition Classes
    Family

Abstract Value Members

  1. abstract def getClass(): Class[_]

    Definition Classes
    Any

  2. abstract def iterator: Iterator[(A, T)]

    Definition Classes
    Container

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  2. final def ##(): Int

    Definition Classes
    Any

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  8. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  9. def apply(key: A): T

  10. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  11. def canEqual(other: Any): Boolean

    Definition Classes
    Map → Equals

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  20. def contains(key: A): Boolean

  21. def equals(other: Any): Boolean

    Definition Classes
    Map → Equals → Any

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

  39. def hashCode(): Int

    Definition Classes
    Map → Any

  40. def isEmpty: Boolean

    Definition Classes
    Container → Collection

  41. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  42. def joinString(separator: String)(implicit builder: StringBuilder): text.StringBuilder.State

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  43. def joinString(open: String, separator: String, close: String)(implicit builder: StringBuilder): text.StringBuilder.State

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  64. def size: Int

  65. def stringPrefix: String

    Attributes
    protected
    Definition Classes
    Collection

  66. def toString(): String

    Definition Classes
    Map → Container → Collection → Any

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

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

    Definition Classes
    Container → Traverser

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

Shadowed Implicit Value Members

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralTraverserOps[(A, T)]).count(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralMapOps[A, T]).count(p)
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralContainerOps[(A, T)]).count(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralCollectionOps[(A, T)]).count(p)
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).drop(lower)(builder)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).drop(lower)(builder)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).drop(lower)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).drop(lower)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).dropWhile(p)(builder)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralTraverserOps[(A, T)]).eagerly
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralMapOps[A, T]).eagerly
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralContainerOps[(A, T)]).eagerly
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralCollectionOps[(A, T)]).eagerly
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralTraverserOps[(A, T)]).exists(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralMapOps[A, T]).exists(p)
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralContainerOps[(A, T)]).exists(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralCollectionOps[(A, T)]).exists(p)
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).filter(p)(builder)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).filter(p)(builder)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).filter(p)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).filter(p)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralTraverserOps[(A, T)]).find(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralMapOps[A, T]).find(p)
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralContainerOps[(A, T)]).find(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralCollectionOps[(A, T)]).find(p)
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralTraverserOps[(A, T)]).forall(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralMapOps[A, T]).forall(p)
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralContainerOps[(A, T)]).forall(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralCollectionOps[(A, T)]).forall(p)
    Definition Classes
    GeneralCollectionOps

  33. def lazily: NonStrictTraverserOps[(A, T)]

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralTraverserOps[(A, T)] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralTraverserOps[(A, T)]).lazily
    Definition Classes
    GeneralTraverserOps

  34. macro def lazily: NonStrictMapOps[A, T]

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralMapOps[A, T] performed by method MapToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralMapOps[A, T]).lazily
    Definition Classes
    GeneralMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralContainerOps[(A, T)] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralContainerOps[(A, T)]).lazily
    Definition Classes
    GeneralContainerOps

  36. def lazily: NonStrictCollectionOps[(A, T)]

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to GeneralCollectionOps[(A, T)] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: GeneralCollectionOps[(A, T)]).lazily
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).slice(lower, upper)(builder)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictCollectionOps

  41. 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)

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictTraverserOps

  42. 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)

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).span(p)(builder1, builder2)
    Definition Classes
    StrictMapOps

  43. 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)

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictContainerOps

  44. 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)

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).take(upper)(builder)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).take(upper)(builder)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).take(upper)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).take(upper)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).takeWhile(p)(builder)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictTraverserOps[(A, T), Traverser[_]]).withFilter(p)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictMapOps[A, T, Map[_, _]] performed by method MapToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictMapOps[A, T, Map[_, _]]).withFilter(p)
    Definition Classes
    StrictMapOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictContainerOps[(A, T), Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictContainerOps[(A, T), Container[_]]).withFilter(p)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (map: StrictCollectionOps[(A, T), Collection[_]]).withFilter(p)
    Definition Classes
    StrictCollectionOps

Inherited from Container[(A, T)]

Inherited from Collection[(A, T)]

Inherited from Traverser[(A, T)]

Inherited from basis.Family[Map[_, _]]

Inherited from Equals

Inherited from Any

Inherited by implicit conversion TraverserToGeneralOps from Map[A, T] to GeneralTraverserOps[(A, T)]

Inherited by implicit conversion MapToGeneralOps from Map[A, T] to GeneralMapOps[A, T]

Inherited by implicit conversion ContainerToGeneralOps from Map[A, T] to GeneralContainerOps[(A, T)]

Inherited by implicit conversion CollectionToGeneralOps from Map[A, T] to GeneralCollectionOps[(A, T)]

Inherited by implicit conversion TraverserToStrictOps from Map[A, T] to StrictTraverserOps[(A, T), Traverser[_]]

Inherited by implicit conversion MapToStrictOps from Map[A, T] to StrictMapOps[A, T, Map[_, _]]

Inherited by implicit conversion ContainerToStrictOps from Map[A, T] to StrictContainerOps[(A, T), Container[_]]

Inherited by implicit conversion CollectionToStrictOps from Map[A, T] to StrictCollectionOps[(A, T), Collection[_]]

Ungrouped