shadedshapeless

productElements

object productElements extends Poly1

Higher ranked function which converts products to HLists.

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

Type Members

  1. type Case[A] = PolyDefns.Case[productElements.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[productElements.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. final def ==(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  6. object Case

    Definition Classes
    Poly1
  7. object CaseBuilder extends LowPriorityCaseBuilder with Serializable

    Definition Classes
    Poly
  8. object ProductCase extends Serializable

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

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

    Definition Classes
    Poly
  11. 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[productElements.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
  12. 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[productElements.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
  13. 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[productElements.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
  14. 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[productElements.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
  15. 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[productElements.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
  16. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  17. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  18. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  19. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  20. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  21. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  22. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  23. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  24. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]): Result

    Definition Classes
    PolyApply
  25. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]]): Result

    Definition Classes
    PolyApply
  26. 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[productElements.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]]): Result

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

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

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

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

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

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

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

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

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

    Definition Classes
    Poly
  36. implicit def caseProduct[P](implicit gen: Generic[P]): Case[P] { type Result = gen.Repr }

  37. def clone(): AnyRef

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

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

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

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

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  42. final def getClass(): Class[_]

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef
  51. def toString(): String

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

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

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from Poly1

Inherited from Poly

Inherited from Serializable

Inherited from Serializable

Inherited from PolyApply

Inherited from AnyRef

Inherited from Any

Ungrouped