shapeless

HMap

class HMap[R[_, _]] extends Poly1

Heterogenous map with type-level key/value associations that are fixed by an arbitrary relation R.

HMaps extend Poly and hence are also polymorphic function values with type-specific cases corresponding to the map's type-level key/value associations.

Linear Supertypes
Poly1, Poly, PolyApply, AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. HMap
  2. Poly1
  3. Poly
  4. PolyApply
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new HMap(underlying: Map[Any, Any] = ...)

Type Members

  1. type Case[A] = PolyDefns.Case[HMap.this.type, ::[A, HNil]]

    Definition Classes
    Poly1
  2. class CaseBuilder[A] extends AnyRef

    Definition Classes
    Poly1Poly
  3. trait LowPriorityCaseBuilder extends AnyRef

    Definition Classes
    Poly
  4. type ProductCase[L <: HList] = PolyDefns.Case[HMap.this.type, L]

    The type of the case representing this polymorphic function at argument types L.

    The type of the case representing this polymorphic function at argument types L.

    Definition Classes
    Poly

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. def +[K, V](kv: (K, V))(implicit ev: R[K, V]): HMap[R]

  5. def -[K](k: K): HMap[R]

  6. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  7. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  8. object Case

    Definition Classes
    Poly1
  9. object CaseBuilder extends LowPriorityCaseBuilder

    Definition Classes
    Poly
  10. object ProductCase

    Definition Classes
    Poly
  11. def andThen(f: Poly): Compose[f.type, HMap.this.type]

    Definition Classes
    Poly
  12. def apply[R](implicit c: Aux[HNil, R]): R

    Definition Classes
    Poly
  13. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S, t: T, u: U, v: V)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  14. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S, t: T, u: U)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  15. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S, t: T)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  16. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  17. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  18. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  19. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  20. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  21. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M, N](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  22. def apply[A, B, C, D, E, F, G, H, I, J, K, L, M](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  23. def apply[A, B, C, D, E, F, G, H, I, J, K, L](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  24. def apply[A, B, C, D, E, F, G, H, I, J, K](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  25. def apply[A, B, C, D, E, F, G, H, I, J](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  26. def apply[A, B, C, D, E, F, G, H, I](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  27. def apply[A, B, C, D, E, F, G, H](a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]]): Result

    Definition Classes
    PolyApply
  28. def apply[A, B, C, D, E, F, G](a: A, b: B, c: C, d: D, e: E, f: F, g: G)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]]): Result

    Definition Classes
    PolyApply
  29. def apply[A, B, C, D, E, F](a: A, b: B, c: C, d: D, e: E, f: F)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]]): Result

    Definition Classes
    PolyApply
  30. def apply[A, B, C, D, E](a: A, b: B, c: C, d: D, e: E)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]]): Result

    Definition Classes
    PolyApply
  31. def apply[A, B, C, D](a: A, b: B, c: C, d: D)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, ::[D, HNil]]]]]): Result

    Definition Classes
    PolyApply
  32. def apply[A, B, C](a: A, b: B, c: C)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, ::[C, HNil]]]]): Result

    Definition Classes
    PolyApply
  33. def apply[A, B](a: A, b: B)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, ::[B, HNil]]]): Result

    Definition Classes
    PolyApply
  34. def apply[A](a: A)(implicit cse: PolyDefns.Case[HMap.this.type, ::[A, HNil]]): Result

    Definition Classes
    PolyApply
  35. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  36. def at[A]: CaseBuilder[A]

    Definition Classes
    Poly1
  37. def caseAt[L <: HList](implicit c: ProductCase[L]): ProductCase[L]

    Definition Classes
    Poly
  38. implicit def caseRel[K, V](implicit ev: R[K, V]): Aux[HMap.this.type, K, V]

  39. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  40. def compose(f: Poly): Compose[HMap.this.type, f.type]

    Definition Classes
    Poly
  41. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  42. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  43. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  44. def get[K, V](k: K)(implicit ev: R[K, V]): Option[V]

  45. final def getClass(): Class[_]

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

    Definition Classes
    AnyRef → Any
  47. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  48. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  49. final def notify(): Unit

    Definition Classes
    AnyRef
  50. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  51. def rotateLeft[N <: Nat]: RotateLeft[HMap.this.type, N]

    Definition Classes
    Poly
  52. def rotateRight[N <: Nat]: RotateRight[HMap.this.type, N]

    Definition Classes
    Poly
  53. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  54. def toString(): String

    Definition Classes
    AnyRef → Any
  55. def use[T, L <: HList, R](t: T)(implicit cb: HMap.CaseBuilder[T, L, R]): Aux[L, R]

    Definition Classes
    Poly
  56. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from Poly1

Inherited from Poly

Inherited from PolyApply

Inherited from AnyRef

Inherited from Any

Ungrouped