Type Members
- type Case[A] = shapeless.PolyDefns.Case[Id.this.type, ::[A, HNil]]
- class CaseBuilder[A] extends AnyRef
- trait LowPriorityCaseBuilder extends AnyRef
- type ProductCase[L <: HList] = shapeless.PolyDefns.Case[Id.this.type, L]
Value Members
- final def !=(arg0: Any): Boolean
- final def ##(): Int
- final def ==(arg0: Any): Boolean
- def andThen(f: Poly): Compose[f.type, Id.this.type]
- def apply[X](c: Codec[X]): Codec[X]
- def apply[R](implicit c: Aux[HNil, R]): R
- 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: shapeless.PolyDefns.Case[Id.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
- 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: shapeless.PolyDefns.Case[Id.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
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]]): Result
- 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: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]]): Result
- def apply[A, B, C, D, E, F](a: A, b: B, c: C, d: D, e: E, f: F)(implicit cse: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]]): Result
- def apply[A, B, C, D, E](a: A, b: B, c: C, d: D, e: E)(implicit cse: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]]): Result
- def apply[A, B, C, D](a: A, b: B, c: C, d: D)(implicit cse: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, ::[D, HNil]]]]]): Result
- def apply[A, B, C](a: A, b: B, c: C)(implicit cse: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, ::[C, HNil]]]]): Result
- def apply[A, B](a: A, b: B)(implicit cse: shapeless.PolyDefns.Case[Id.this.type, ::[A, ::[B, HNil]]]): Result
- def apply[A](a: A)(implicit cse: shapeless.PolyDefns.Case[Id.this.type, ::[A, HNil]]): Result
- final def asInstanceOf[T0]: T0
- def at[A]: CaseBuilder[A]
- def caseAt[L <: HList](implicit c: ProductCase[L]): ProductCase[L]
- implicit def caseUniv[T]: Aux[Codec[T], Codec[T]]
- def clone(): AnyRef
- def compose(f: Poly): Compose[Id.this.type, f.type]
- final def eq(arg0: AnyRef): Boolean
- def equals(arg0: AnyRef): Boolean
- def finalize(): Unit
- final def getClass(): Class[_ <: AnyRef]
- def hashCode(): Int
- final def isInstanceOf[T0]: Boolean
- final def ne(arg0: AnyRef): Boolean
- final def notify(): Unit
- final def notifyAll(): Unit
- def rotateLeft[N <: Nat]: RotateLeft[Id.this.type, N]
- def rotateRight[N <: Nat]: RotateRight[Id.this.type, N]
- final def synchronized[T0](arg0: => T0): T0
- def toString(): String
- def use[T, L <: HList, R](t: T)(implicit cb: Id.CaseBuilder[T, L, R]): Aux[L, R]
- final def wait(): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- final def wait(arg0: Long): Unit
- object ProductCase extends Serializable
Inherited from Poly1
Inherited from Poly
Inherited from Serializable
Inherited from PolyApply
Inherited from AnyRef
Inherited from Any