Class/Object

scalaz

==>>

Related Docs: object ==>> | package scalaz

Permalink

sealed abstract class ==>>[A, B] extends AnyRef

An immutable map of key/value pairs implemented as a balanced binary tree

Based on Haskell's Data.Map

Source
Map.scala
Since

7.0.3

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ==>>
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract val size: Int

    Permalink

    number of key/value pairs - O(1)

Concrete Value Members

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

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. def +(a: (A, B))(implicit o: Order[A]): ==>>[A, B]

    Permalink

    tupled form of insert

  4. def -(k: A)(implicit o: Order[A]): ==>>[A, B]

    Permalink

    alias for delete

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

    Permalink
    Definition Classes
    AnyRef → Any
  6. def \\(other: ==>>[A, B])(implicit o: Order[A]): ==>>[A, B]

    Permalink
  7. def adjust(k: A, f: (B) ⇒ B)(implicit o: Order[A]): ==>>[A, B]

    Permalink

    if the key exists, transforms its value - O(log n)

  8. def adjustWithKey(k: A, f: (A, B) ⇒ B)(implicit o: Order[A]): ==>>[A, B]

    Permalink

    like adjust but with the key available in the transformation - O(log n)

  9. def alter(k: A, f: (Option[B]) ⇒ Option[B])(implicit o: Order[A]): ==>>[A, B]

    Permalink
  10. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  11. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  12. def delete(k: A)(implicit n: Order[A]): ==>>[A, B]

    Permalink

    removes a key/value pair - O(log n)

  13. def deleteAt(i: Int): ==>>[A, B]

    Permalink
  14. def deleteMax: ==>>[A, B]

    Permalink
  15. def deleteMin: ==>>[A, B]

    Permalink
  16. def difference(other: ==>>[A, B])(implicit o: Order[A]): ==>>[A, B]

    Permalink
  17. def differenceWith[C](other: ==>>[A, C], f: (B, C) ⇒ Option[B])(implicit o: Order[A]): ==>>[A, B]

    Permalink
  18. def differenceWithKey[C](other: ==>>[A, C], f: (A, B, C) ⇒ Option[B])(implicit o: Order[A]): ==>>[A, B]

    Permalink
  19. final def elemAt(i: Int): Option[(A, B)]

    Permalink
    Annotations
    @tailrec()
  20. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  21. def equals(other: Any): Boolean

    Permalink
    Definition Classes
    ==>> → AnyRef → Any
  22. def filter(p: (B) ⇒ Boolean)(implicit o: Order[A]): ==>>[A, B]

    Permalink
  23. def filterWithKey(p: (A, B) ⇒ Boolean)(implicit o: Order[A]): ==>>[A, B]

    Permalink
  24. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  25. final def findMax: Option[(A, B)]

    Permalink
    Annotations
    @tailrec()
  26. final def findMin: Option[(A, B)]

    Permalink
    Annotations
    @tailrec()
  27. def fold[C](z: C)(f: (A, B, C) ⇒ C): C

    Permalink
  28. def foldlWithKey[C](z: C)(f: (C, A, B) ⇒ C): C

    Permalink
  29. def foldrWithKey[C](z: C)(f: (A, B, C) ⇒ C): C

    Permalink
  30. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  31. def hashCode(): Int

    Permalink
    Definition Classes
    ==>> → AnyRef → Any
  32. def insert(kx: A, x: B)(implicit n: Order[A]): ==>>[A, B]

    Permalink

    inserts a new key/value - O(log n).

    inserts a new key/value - O(log n).

    If the key is already present, its value is replaced by the provided value.

  33. def insertWith(f: (B, B) ⇒ B, kx: A, x: B)(implicit o: Order[A]): ==>>[A, B]

    Permalink

    inserts a new key/value pair, resolving the conflict if the key already exists - O(log n)

    inserts a new key/value pair, resolving the conflict if the key already exists - O(log n)

    f

    function to resolve conflict with existing key: (insertedValue, existingValue) => resolvedValue

    kx

    key

    x

    value to insert if the key is not already present

  34. def insertWithKey(f: (A, B, B) ⇒ B, kx: A, x: B)(implicit o: Order[A]): ==>>[A, B]

    Permalink

    inserts a new key/value pair, resolving the conflict if the key already exists - O(log n)

    inserts a new key/value pair, resolving the conflict if the key already exists - O(log n)

    f

    function to resolve conflict with existing key: (key, insertedValue, existingValue) => resolvedValue

    kx

    key

    x

    value to insert if the key is not already present

  35. def intersection[C](other: ==>>[A, C])(implicit o: Order[A]): ==>>[A, B]

    Permalink
  36. def intersectionWith[C, D](other: ==>>[A, C])(f: (B, C) ⇒ D)(implicit o: Order[A]): ==>>[A, D]

    Permalink
  37. def intersectionWithKey[C, D](other: ==>>[A, C])(f: (A, B, C) ⇒ D)(implicit o: Order[A]): ==>>[A, D]

    Permalink
  38. def isEmpty: Boolean

    Permalink

    returns true if this map contains no key/value pairs - O(1)

  39. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  40. def isSubmapOf(a: ==>>[A, B])(implicit o: Order[A], e: Equal[B]): Boolean

    Permalink
  41. def isSubmapOfBy(a: ==>>[A, B], f: (B, B) ⇒ Boolean)(implicit o: Order[A]): Boolean

    Permalink
  42. def join(kx: A, x: B, other: ==>>[A, B])(implicit o: Order[A]): ==>>[A, B]

    Permalink
    Attributes
    protected
  43. def keySet: Set[A]

    Permalink
  44. def keys: List[A]

    Permalink
  45. final def lookup(k: A)(implicit n: Order[A]): Option[B]

    Permalink
    Annotations
    @tailrec()
  46. final def lookupAssoc(k: A)(implicit n: Order[A]): Option[(A, B)]

    Permalink
    Annotations
    @tailrec()
  47. def lookupIndex(k: A)(implicit o: Order[A]): Option[Int]

    Permalink
  48. def map[C](f: (B) ⇒ C): ==>>[A, C]

    Permalink
  49. def mapAccum[C](z: C)(f: (C, B) ⇒ (C, B)): (C, ==>>[A, B])

    Permalink
  50. def mapAccumL[C](a: C)(f: (C, A, B) ⇒ (C, B)): (C, ==>>[A, B])

    Permalink
  51. def mapAccumWithKey[C](z: C)(f: (C, A, B) ⇒ (C, B)): (C, ==>>[A, B])

    Permalink
  52. def mapEither[C, D](f: (B) ⇒ \/[C, D])(implicit o: Order[A]): (==>>[A, C], ==>>[A, D])

    Permalink
  53. def mapEitherWithKey[C, D](f: (A, B) ⇒ \/[C, D])(implicit o: Order[A]): (==>>[A, C], ==>>[A, D])

    Permalink
  54. def mapKeys[C](f: (A) ⇒ C)(implicit o: Order[C]): ==>>[C, B]

    Permalink
  55. def mapKeysWith[C](f: (A) ⇒ C, f2: (B, B) ⇒ B)(implicit o: Order[C]): ==>>[C, B]

    Permalink
  56. def mapOption[C](f: (B) ⇒ Option[C])(implicit o: Order[A]): ==>>[A, C]

    Permalink
  57. def mapOptionWithKey[C](f: (A, B) ⇒ Option[C])(implicit o: Order[A]): ==>>[A, C]

    Permalink
  58. def mapWithKey[C](f: (A, B) ⇒ C): ==>>[A, C]

    Permalink
  59. def maxView: Option[(B, ==>>[A, B])]

    Permalink
  60. def maxViewWithKey: Option[((A, B), ==>>[A, B])]

    Permalink
  61. def member(k: A)(implicit n: Order[A]): Boolean

    Permalink
  62. def merge(other: ==>>[A, B]): ==>>[A, B]

    Permalink
    Attributes
    protected
  63. def minView: Option[(B, ==>>[A, B])]

    Permalink
  64. def minViewWithKey: Option[((A, B), ==>>[A, B])]

    Permalink
  65. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  66. def notMember(k: A)(implicit n: Order[A]): Boolean

    Permalink
  67. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  68. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  69. def partition(p: (B) ⇒ Boolean)(implicit o: Order[A]): (==>>[A, B], ==>>[A, B])

    Permalink
  70. def partitionWithKey(p: (A, B) ⇒ Boolean)(implicit o: Order[A]): (==>>[A, B], ==>>[A, B])

    Permalink
  71. def split(k: A)(implicit o: Order[A]): (==>>[A, B], ==>>[A, B])

    Permalink
  72. def splitLookup(k: A)(implicit o: Order[A]): (==>>[A, B], Option[B], ==>>[A, B])

    Permalink
  73. def splitLookupWithKey(k: A)(implicit o: Order[A]): (==>>[A, B], Option[(A, B)], ==>>[A, B])

    Permalink
  74. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  75. def toAscList: List[(A, B)]

    Permalink
  76. def toDescList: List[(A, B)]

    Permalink
  77. def toList: List[(A, B)]

    Permalink
  78. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  79. final def trim(lo: (A) ⇒ Ordering, hi: (A) ⇒ Ordering): ==>>[A, B]

    Permalink
    Annotations
    @tailrec()
  80. final def trimLookupLo(lo: A, cmphi: (A) ⇒ Ordering)(implicit o: Order[A]): (Option[(A, B)], ==>>[A, B])

    Permalink
    Annotations
    @tailrec()
  81. def union(other: ==>>[A, B])(implicit k: Order[A]): ==>>[A, B]

    Permalink
  82. def unionWith(other: ==>>[A, B])(f: (B, B) ⇒ B)(implicit o: Order[A]): ==>>[A, B]

    Permalink
  83. def unionWithKey(other: ==>>[A, B])(f: (A, B, B) ⇒ B)(implicit o: Order[A]): ==>>[A, B]

    Permalink
  84. def update(k: A, f: (B) ⇒ Option[B])(implicit o: Order[A]): ==>>[A, B]

    Permalink

    updates or removes a value - O(log n)

    updates or removes a value - O(log n)

    if f returns None, then the key is removed from the map

  85. def updateAppend(k: A, v: B)(implicit o: Order[A], bsg: Semigroup[B]): ==>>[A, B]

    Permalink

    insert v into the map at k.

    insert v into the map at k. If there is already a value for k, append to the existing value using the Semigroup

  86. def updateAt(i: Int, f: (A, B) ⇒ Option[B]): ==>>[A, B]

    Permalink
  87. def updateLookupWithKey(k: A, f: (A, B) ⇒ Option[B])(implicit o: Order[A]): (Option[B], ==>>[A, B])

    Permalink

    looks up a key and updates its value - O(log n)

    looks up a key and updates its value - O(log n)

    Similar to updateWithKey but also returns the value. If the value was updated, returns the new value. If the value was deleted, returns the old value.

  88. def updateMax(f: (B) ⇒ Option[B]): ==>>[A, B]

    Permalink
  89. def updateMaxWithKey(f: (A, B) ⇒ Option[B]): ==>>[A, B]

    Permalink
  90. def updateMin(f: (B) ⇒ Option[B]): ==>>[A, B]

    Permalink
  91. def updateMinWithKey(f: (A, B) ⇒ Option[B]): ==>>[A, B]

    Permalink
  92. def updateWithKey(k: A, f: (A, B) ⇒ Option[B])(implicit o: Order[A]): ==>>[A, B]

    Permalink

    like update but with the key available in the update function - O(log n)

  93. def values: List[B]

    Permalink
  94. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  95. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  96. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped