com.thoughtworks.deeplearning.Poly

LayerPoly1

trait LayerPoly1 extends Poly1

Linear Supertypes
Poly1, shapeless.Poly, Serializable, Serializable, PolyApply, AnyRef, Any
Known Subclasses
abs, exp, log
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. LayerPoly1
  2. Poly1
  3. Poly
  4. Serializable
  5. Serializable
  6. PolyApply
  7. AnyRef
  8. Any
Implicitly
  1. by inst22
  2. by inst21
  3. by inst20
  4. by inst19
  5. by inst18
  6. by inst17
  7. by inst16
  8. by inst15
  9. by inst14
  10. by inst13
  11. by inst12
  12. by inst11
  13. by inst10
  14. by inst9
  15. by inst8
  16. by inst7
  17. by inst6
  18. by inst5
  19. by inst4
  20. by inst3
  21. by inst2
  22. by inst1
  23. by MathOps
  24. by any2stringadd
  25. by any2stringfmt
  26. by any2ArrowAssoc
  27. by any2Ensuring
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

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

    Definition Classes
    Poly1

  2. class CaseBuilder[A] extends AnyRef

    Definition Classes
    Poly1 → Poly

  3. trait LowPriorityCaseBuilder extends AnyRef

    Definition Classes
    Poly

  4. type ProductCase[L <: HList] = shapeless.PolyDefns.Case[LayerPoly1.this.type, 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 *[Right](right: Right)(implicit methodCase: MathMethods.*.Case[LayerPoly1, Right]): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to MathOps[LayerPoly1] performed by method MathOps in com.thoughtworks.deeplearning.Poly.
    Definition Classes
    MathOps

  5. def +[Right](right: Right)(implicit methodCase: MathMethods.+.Case[LayerPoly1, Right]): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to MathOps[LayerPoly1] performed by method MathOps in com.thoughtworks.deeplearning.Poly.
    Definition Classes
    MathOps

  6. def +(other: String): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to StringAdd performed by method any2stringadd in scala.Predef.
    Definition Classes
    StringAdd

  7. def -[Right](right: Right)(implicit methodCase: MathMethods.-.Case[LayerPoly1, Right]): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to MathOps[LayerPoly1] performed by method MathOps in com.thoughtworks.deeplearning.Poly.
    Definition Classes
    MathOps

  8. def ->[B](y: B): (LayerPoly1, B)

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to ArrowAssoc[LayerPoly1] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()

  9. def /[Right](right: Right)(implicit methodCase: MathMethods./.Case[LayerPoly1, Right]): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to MathOps[LayerPoly1] performed by method MathOps in com.thoughtworks.deeplearning.Poly.
    Definition Classes
    MathOps

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

    Definition Classes
    AnyRef

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

    Definition Classes
    Any

  12. object Case

    Definition Classes
    Poly1

  13. object ProductCase extends Serializable

    Definition Classes
    Poly

  14. def andThen(f: shapeless.Poly): Compose[f.type, LayerPoly1.this.type]

    Definition Classes
    Poly

  15. def apply[R](implicit c: Aux[HNil, R]): R

    Definition Classes
    Poly

  16. 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[LayerPoly1.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

  17. 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[LayerPoly1.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

  18. 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[LayerPoly1.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

  19. 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[LayerPoly1.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

  20. 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[LayerPoly1.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

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

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

    Definition Classes
    PolyApply

  29. 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[LayerPoly1.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]): Result

    Definition Classes
    PolyApply

  30. 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[LayerPoly1.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]]): Result

    Definition Classes
    PolyApply

  31. 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[LayerPoly1.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]]): Result

    Definition Classes
    PolyApply

  32. 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[LayerPoly1.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]]): Result

    Definition Classes
    PolyApply

  33. def apply[A, B, C, D, E](a: A, b: B, c: C, d: D, e: E)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]]): Result

    Definition Classes
    PolyApply

  34. def apply[A, B, C, D](a: A, b: B, c: C, d: D)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, ::[B, ::[C, ::[D, HNil]]]]]): Result

    Definition Classes
    PolyApply

  35. def apply[A, B, C](a: A, b: B, c: C)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, ::[B, ::[C, HNil]]]]): Result

    Definition Classes
    PolyApply

  36. def apply[A, B](a: A, b: B)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, ::[B, HNil]]]): Result

    Definition Classes
    PolyApply

  37. def apply[A](a: A)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, HNil]]): Result

    Definition Classes
    PolyApply

  38. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  39. def at[A]: CaseBuilder[A]

    Definition Classes
    Poly1

  40. def caseAt[L <: HList](implicit c: ProductCase[L]): ProductCase[L]

    Definition Classes
    Poly

  41. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  42. def compose(f: shapeless.Poly): Compose[LayerPoly1.this.type, f.type]

    Definition Classes
    Poly

  43. def ensuring(cond: (LayerPoly1) ⇒ Boolean, msg: ⇒ Any): LayerPoly1

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  44. def ensuring(cond: (LayerPoly1) ⇒ Boolean): LayerPoly1

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  45. def ensuring(cond: Boolean, msg: ⇒ Any): LayerPoly1

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  46. def ensuring(cond: Boolean): LayerPoly1

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  47. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  48. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  49. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  50. def formatted(fmtstr: String): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()

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

    Definition Classes
    AnyRef → Any

  52. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  53. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  54. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  55. final def notify(): Unit

    Definition Classes
    AnyRef

  56. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  57. def rotateLeft[N <: Nat]: RotateLeft[LayerPoly1.this.type, N]

    Definition Classes
    Poly

  58. def rotateRight[N <: Nat]: RotateRight[LayerPoly1.this.type, N]

    Definition Classes
    Poly

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

    Definition Classes
    AnyRef

  60. implicit def toLayerCase[Operand, Input <: Batch, OperandData, OperandDelta](implicit toLayer: Aux[Operand, Input, OperandData, OperandDelta], layerCase: Lazy[Case[Aux[Input, Aux[OperandData, OperandDelta]]]]): Aux[Operand, Result]

  61. def toString(): String

    Definition Classes
    AnyRef → Any

  62. def use[T, L <: HList, R](t: T)(implicit cb: LayerPoly1.CaseBuilder[T, L, R]): Aux[L, R]

    Definition Classes
    Poly

  63. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  64. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  65. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  66. def →[B](y: B): (LayerPoly1, B)

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to ArrowAssoc[LayerPoly1] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Shadowed Implicit Value Members

  1. def andThen[A](g: (Result) ⇒ A): (A) ⇒ A

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A) ⇒ Result performed by method inst1 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, HNil]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A) ⇒ Result).andThen(g)
    Definition Classes
    Function1
    Annotations
    @unspecialized()

  2. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P, v17: Q, v18: R, v19: S, v20: T, v21: U, v22: V): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result performed by method inst22 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
    Definition Classes
    Function22

  3. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P, v17: Q, v18: R, v19: S, v20: T, v21: U): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result performed by method inst21 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
    Definition Classes
    Function21

  4. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P, v17: Q, v18: R, v19: S, v20: T): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result performed by method inst20 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
    Definition Classes
    Function20

  5. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P, v17: Q, v18: R, v19: S): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result performed by method inst19 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
    Definition Classes
    Function19

  6. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P, v17: Q, v18: R): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result performed by method inst18 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
    Definition Classes
    Function18

  7. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P, v17: Q): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result performed by method inst17 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
    Definition Classes
    Function17

  8. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O, v16: P): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result performed by method inst16 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
    Definition Classes
    Function16

  9. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N, v15: O): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result performed by method inst15 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
    Definition Classes
    Function15

  10. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M, v14: N): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result performed by method inst14 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
    Definition Classes
    Function14

  11. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L, v13: M): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result performed by method inst13 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
    Definition Classes
    Function13

  12. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K, v12: L): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result performed by method inst12 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
    Definition Classes
    Function12

  13. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J, v11: K): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result performed by method inst11 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
    Definition Classes
    Function11

  14. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I, v10: J): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J) ⇒ Result performed by method inst10 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
    Definition Classes
    Function10

  15. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H, v9: I): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I) ⇒ Result performed by method inst9 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8, v9)
    Definition Classes
    Function9

  16. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G, v8: H): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H) ⇒ Result performed by method inst8 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7, v8)
    Definition Classes
    Function8

  17. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, v7: G): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G) ⇒ Result performed by method inst7 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G) ⇒ Result).apply(v1, v2, v3, v4, v5, v6, v7)
    Definition Classes
    Function7

  18. def apply(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F) ⇒ Result performed by method inst6 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F) ⇒ Result).apply(v1, v2, v3, v4, v5, v6)
    Definition Classes
    Function6

  19. def apply(v1: A, v2: B, v3: C, v4: D, v5: E): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E) ⇒ Result performed by method inst5 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E) ⇒ Result).apply(v1, v2, v3, v4, v5)
    Definition Classes
    Function5

  20. def apply(v1: A, v2: B, v3: C, v4: D): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D) ⇒ Result performed by method inst4 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, HNil]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D) ⇒ Result).apply(v1, v2, v3, v4)
    Definition Classes
    Function4

  21. def apply(v1: A, v2: B, v3: C): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C) ⇒ Result performed by method inst3 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, HNil]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C) ⇒ Result).apply(v1, v2, v3)
    Definition Classes
    Function3

  22. def apply(v1: A, v2: B): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B) ⇒ Result performed by method inst2 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, HNil]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B) ⇒ Result).apply(v1, v2)
    Definition Classes
    Function2

  23. def apply(v1: A): Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A) ⇒ Result performed by method inst1 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, HNil]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A) ⇒ Result).apply(v1)
    Definition Classes
    Function1

  24. def compose[A](g: (A) ⇒ A): (A) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A) ⇒ Result performed by method inst1 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, HNil]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A) ⇒ Result).compose(g)
    Definition Classes
    Function1
    Annotations
    @unspecialized()

  25. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ (Q) ⇒ (R) ⇒ (S) ⇒ (T) ⇒ (U) ⇒ (V) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result performed by method inst22 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result).curried
    Definition Classes
    Function22
    Annotations
    @unspecialized()

  26. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ (Q) ⇒ (R) ⇒ (S) ⇒ (T) ⇒ (U) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result performed by method inst21 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result).curried
    Definition Classes
    Function21
    Annotations
    @unspecialized()

  27. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ (Q) ⇒ (R) ⇒ (S) ⇒ (T) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result performed by method inst20 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result).curried
    Definition Classes
    Function20
    Annotations
    @unspecialized()

  28. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ (Q) ⇒ (R) ⇒ (S) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result performed by method inst19 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result).curried
    Definition Classes
    Function19
    Annotations
    @unspecialized()

  29. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ (Q) ⇒ (R) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result performed by method inst18 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result).curried
    Definition Classes
    Function18
    Annotations
    @unspecialized()

  30. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ (Q) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result performed by method inst17 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result).curried
    Definition Classes
    Function17
    Annotations
    @unspecialized()

  31. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ (P) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result performed by method inst16 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result).curried
    Definition Classes
    Function16
    Annotations
    @unspecialized()

  32. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ (O) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result performed by method inst15 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result).curried
    Definition Classes
    Function15
    Annotations
    @unspecialized()

  33. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ (N) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result performed by method inst14 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result).curried
    Definition Classes
    Function14
    Annotations
    @unspecialized()

  34. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ (M) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result performed by method inst13 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result).curried
    Definition Classes
    Function13
    Annotations
    @unspecialized()

  35. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ (L) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result performed by method inst12 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result).curried
    Definition Classes
    Function12
    Annotations
    @unspecialized()

  36. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ (K) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result performed by method inst11 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result).curried
    Definition Classes
    Function11
    Annotations
    @unspecialized()

  37. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ (J) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J) ⇒ Result performed by method inst10 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J) ⇒ Result).curried
    Definition Classes
    Function10
    Annotations
    @unspecialized()

  38. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ (I) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I) ⇒ Result performed by method inst9 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I) ⇒ Result).curried
    Definition Classes
    Function9
    Annotations
    @unspecialized()

  39. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ (H) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H) ⇒ Result performed by method inst8 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H) ⇒ Result).curried
    Definition Classes
    Function8
    Annotations
    @unspecialized()

  40. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ (G) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G) ⇒ Result performed by method inst7 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G) ⇒ Result).curried
    Definition Classes
    Function7
    Annotations
    @unspecialized()

  41. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ (F) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F) ⇒ Result performed by method inst6 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F) ⇒ Result).curried
    Definition Classes
    Function6
    Annotations
    @unspecialized()

  42. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ (E) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E) ⇒ Result performed by method inst5 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E) ⇒ Result).curried
    Definition Classes
    Function5
    Annotations
    @unspecialized()

  43. def curried: (A) ⇒ (B) ⇒ (C) ⇒ (D) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D) ⇒ Result performed by method inst4 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, HNil]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D) ⇒ Result).curried
    Definition Classes
    Function4
    Annotations
    @unspecialized()

  44. def curried: (A) ⇒ (B) ⇒ (C) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C) ⇒ Result performed by method inst3 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, HNil]]]] is in scope.
    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:
    (layerPoly1: (A, B, C) ⇒ Result).curried
    Definition Classes
    Function3
    Annotations
    @unspecialized()

  45. def curried: (A) ⇒ (B) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B) ⇒ Result performed by method inst2 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, HNil]]] is in scope.
    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:
    (layerPoly1: (A, B) ⇒ Result).curried
    Definition Classes
    Function2
    Annotations
    @unspecialized()

  46. val self: Any

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to StringAdd performed by method any2stringadd in scala.Predef.
    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:
    (layerPoly1: StringAdd).self
    Definition Classes
    StringAdd

  47. val self: Any

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to StringFormat performed by method any2stringfmt in scala.Predef.
    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:
    (layerPoly1: StringFormat).self
    Definition Classes
    StringFormat

  48. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result performed by method inst22 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result).toString()
    Definition Classes
    Function22 → AnyRef → Any

  49. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result performed by method inst21 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result).toString()
    Definition Classes
    Function21 → AnyRef → Any

  50. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result performed by method inst20 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result).toString()
    Definition Classes
    Function20 → AnyRef → Any

  51. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result performed by method inst19 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result).toString()
    Definition Classes
    Function19 → AnyRef → Any

  52. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result performed by method inst18 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result).toString()
    Definition Classes
    Function18 → AnyRef → Any

  53. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result performed by method inst17 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result).toString()
    Definition Classes
    Function17 → AnyRef → Any

  54. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result performed by method inst16 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result).toString()
    Definition Classes
    Function16 → AnyRef → Any

  55. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result performed by method inst15 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result).toString()
    Definition Classes
    Function15 → AnyRef → Any

  56. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result performed by method inst14 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result).toString()
    Definition Classes
    Function14 → AnyRef → Any

  57. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result performed by method inst13 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result).toString()
    Definition Classes
    Function13 → AnyRef → Any

  58. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result performed by method inst12 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result).toString()
    Definition Classes
    Function12 → AnyRef → Any

  59. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result performed by method inst11 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result).toString()
    Definition Classes
    Function11 → AnyRef → Any

  60. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J) ⇒ Result performed by method inst10 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J) ⇒ Result).toString()
    Definition Classes
    Function10 → AnyRef → Any

  61. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I) ⇒ Result performed by method inst9 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H, I) ⇒ Result).toString()
    Definition Classes
    Function9 → AnyRef → Any

  62. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H) ⇒ Result performed by method inst8 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G, H) ⇒ Result).toString()
    Definition Classes
    Function8 → AnyRef → Any

  63. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G) ⇒ Result performed by method inst7 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F, G) ⇒ Result).toString()
    Definition Classes
    Function7 → AnyRef → Any

  64. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F) ⇒ Result performed by method inst6 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E, F) ⇒ Result).toString()
    Definition Classes
    Function6 → AnyRef → Any

  65. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E) ⇒ Result performed by method inst5 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D, E) ⇒ Result).toString()
    Definition Classes
    Function5 → AnyRef → Any

  66. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D) ⇒ Result performed by method inst4 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, HNil]]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C, D) ⇒ Result).toString()
    Definition Classes
    Function4 → AnyRef → Any

  67. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C) ⇒ Result performed by method inst3 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, HNil]]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B, C) ⇒ Result).toString()
    Definition Classes
    Function3 → AnyRef → Any

  68. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B) ⇒ Result performed by method inst2 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, HNil]]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A, B) ⇒ Result).toString()
    Definition Classes
    Function2 → AnyRef → Any

  69. def toString(): String

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A) ⇒ Result performed by method inst1 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, HNil]] is in scope.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (layerPoly1: (A) ⇒ Result).toString()
    Definition Classes
    Function1 → AnyRef → Any

  70. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result performed by method inst22 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result).tupled
    Definition Classes
    Function22
    Annotations
    @unspecialized()

  71. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result performed by method inst21 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result).tupled
    Definition Classes
    Function21
    Annotations
    @unspecialized()

  72. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result performed by method inst20 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result).tupled
    Definition Classes
    Function20
    Annotations
    @unspecialized()

  73. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result performed by method inst19 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result).tupled
    Definition Classes
    Function19
    Annotations
    @unspecialized()

  74. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result performed by method inst18 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result).tupled
    Definition Classes
    Function18
    Annotations
    @unspecialized()

  75. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result performed by method inst17 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result).tupled
    Definition Classes
    Function17
    Annotations
    @unspecialized()

  76. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result performed by method inst16 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result).tupled
    Definition Classes
    Function16
    Annotations
    @unspecialized()

  77. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result performed by method inst15 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result).tupled
    Definition Classes
    Function15
    Annotations
    @unspecialized()

  78. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result performed by method inst14 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result).tupled
    Definition Classes
    Function14
    Annotations
    @unspecialized()

  79. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result performed by method inst13 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result).tupled
    Definition Classes
    Function13
    Annotations
    @unspecialized()

  80. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result performed by method inst12 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result).tupled
    Definition Classes
    Function12
    Annotations
    @unspecialized()

  81. def tupled: ((A, B, C, D, E, F, G, H, I, J, K)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result performed by method inst11 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result).tupled
    Definition Classes
    Function11
    Annotations
    @unspecialized()

  82. def tupled: ((A, B, C, D, E, F, G, H, I, J)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J) ⇒ Result performed by method inst10 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I, J) ⇒ Result).tupled
    Definition Classes
    Function10
    Annotations
    @unspecialized()

  83. def tupled: ((A, B, C, D, E, F, G, H, I)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H, I) ⇒ Result performed by method inst9 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H, I) ⇒ Result).tupled
    Definition Classes
    Function9
    Annotations
    @unspecialized()

  84. def tupled: ((A, B, C, D, E, F, G, H)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G, H) ⇒ Result performed by method inst8 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G, H) ⇒ Result).tupled
    Definition Classes
    Function8
    Annotations
    @unspecialized()

  85. def tupled: ((A, B, C, D, E, F, G)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F, G) ⇒ Result performed by method inst7 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F, G) ⇒ Result).tupled
    Definition Classes
    Function7
    Annotations
    @unspecialized()

  86. def tupled: ((A, B, C, D, E, F)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E, F) ⇒ Result performed by method inst6 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E, F) ⇒ Result).tupled
    Definition Classes
    Function6
    Annotations
    @unspecialized()

  87. def tupled: ((A, B, C, D, E)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D, E) ⇒ Result performed by method inst5 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D, E) ⇒ Result).tupled
    Definition Classes
    Function5
    Annotations
    @unspecialized()

  88. def tupled: ((A, B, C, D)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C, D) ⇒ Result performed by method inst4 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, ::[D, HNil]]]]] is in scope.
    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:
    (layerPoly1: (A, B, C, D) ⇒ Result).tupled
    Definition Classes
    Function4
    Annotations
    @unspecialized()

  89. def tupled: ((A, B, C)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B, C) ⇒ Result performed by method inst3 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, ::[C, HNil]]]] is in scope.
    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:
    (layerPoly1: (A, B, C) ⇒ Result).tupled
    Definition Classes
    Function3
    Annotations
    @unspecialized()

  90. def tupled: ((A, B)) ⇒ Result

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to (A, B) ⇒ Result performed by method inst2 in shapeless.PolyInst. This conversion will take place only if an implicit value of type ProductCase[::[A, ::[B, HNil]]] is in scope.
    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:
    (layerPoly1: (A, B) ⇒ Result).tupled
    Definition Classes
    Function2
    Annotations
    @unspecialized()

Deprecated Value Members

  1. def x: LayerPoly1

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to ArrowAssoc[LayerPoly1] performed by method any2ArrowAssoc in scala.Predef.
    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:
    (layerPoly1: ArrowAssoc[LayerPoly1]).x
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use leftOfArrow instead

  2. def x: LayerPoly1

    Implicit information
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method any2Ensuring in scala.Predef.
    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:
    (layerPoly1: Ensuring[LayerPoly1]).x
    Definition Classes
    Ensuring
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use resultOfEnsuring instead

Inherited from Poly1

Inherited from shapeless.Poly

Inherited from Serializable

Inherited from Serializable

Inherited from PolyApply

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion inst22 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ Result

Inherited by implicit conversion inst21 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ Result

Inherited by implicit conversion inst20 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ Result

Inherited by implicit conversion inst19 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Result

Inherited by implicit conversion inst18 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ Result

Inherited by implicit conversion inst17 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ Result

Inherited by implicit conversion inst16 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Result

Inherited by implicit conversion inst15 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ Result

Inherited by implicit conversion inst14 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ Result

Inherited by implicit conversion inst13 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ Result

Inherited by implicit conversion inst12 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Result

Inherited by implicit conversion inst11 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J, K) ⇒ Result

Inherited by implicit conversion inst10 from LayerPoly1 to (A, B, C, D, E, F, G, H, I, J) ⇒ Result

Inherited by implicit conversion inst9 from LayerPoly1 to (A, B, C, D, E, F, G, H, I) ⇒ Result

Inherited by implicit conversion inst8 from LayerPoly1 to (A, B, C, D, E, F, G, H) ⇒ Result

Inherited by implicit conversion inst7 from LayerPoly1 to (A, B, C, D, E, F, G) ⇒ Result

Inherited by implicit conversion inst6 from LayerPoly1 to (A, B, C, D, E, F) ⇒ Result

Inherited by implicit conversion inst5 from LayerPoly1 to (A, B, C, D, E) ⇒ Result

Inherited by implicit conversion inst4 from LayerPoly1 to (A, B, C, D) ⇒ Result

Inherited by implicit conversion inst3 from LayerPoly1 to (A, B, C) ⇒ Result

Inherited by implicit conversion inst2 from LayerPoly1 to (A, B) ⇒ Result

Inherited by implicit conversion inst1 from LayerPoly1 to (A) ⇒ Result

Inherited by implicit conversion MathOps from LayerPoly1 to MathOps[LayerPoly1]

Inherited by implicit conversion any2stringadd from LayerPoly1 to StringAdd

Inherited by implicit conversion any2stringfmt from LayerPoly1 to StringFormat

Inherited by implicit conversion any2ArrowAssoc from LayerPoly1 to ArrowAssoc[LayerPoly1]

Inherited by implicit conversion any2Ensuring from LayerPoly1 to Ensuring[LayerPoly1]

Ungrouped