Packages

  • package root
    Definition Classes
    root
  • package com
    Definition Classes
    root
  • package thoughtworks
    Definition Classes
    com
  • package deeplearning

    This is the documentation for the DeepLearning.Scala

    This is the documentation for the DeepLearning.Scala

    Overview

    BufferedLayer, DifferentiableAny, DifferentiableNothing, Layer, Poly and Symbolic are base packages which contains necessary operations , all other packages dependent on those base packages.

    If you want to implement a layer, you need to know how to use base packages.

    Imports guidelines

    If you want use some operations of Type T, you should import:

    import com.thoughtworks.deeplearning.DifferentiableT._

    it means: If you want use some operations of INDArray, you should import:

    import com.thoughtworks.deeplearning.DifferentiableINDArray._

    If you write something like this:

    def softmax(implicit scores: INDArray @Symbolic): INDArray @Symbolic = {
  val expScores = exp(scores)
  expScores / expScores.sum(1)
}

    If compiler shows error :

    Could not infer implicit value for com.thoughtworks.deeplearning.Symbolic[org.nd4j.linalg.api.ndarray.INDArray]

    you need add import this time :

    import com.thoughtworks.deeplearning.DifferentiableINDArray._

    If you write something like this:

    def crossEntropyLossFunction(
  implicit pair: (INDArray :: INDArray :: HNil) @Symbolic)
: Double @Symbolic = {
 val score = pair.head
 val label = pair.tail.head
 -(label * log(score * 0.9 + 0.1) + (1.0 - label) * log(1.0 - score * 0.9)).mean
}

    If the compiler shows error:

    value * is not a member of com.thoughtworks.deeplearning.Layer.Aux[com.thoughtworks.deeplearning.Layer.Tape.Aux[org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray],com.thoughtworks.deeplearning.DifferentiableINDArray.INDArrayPlaceholder.Tape]val bias = Nd4j.ones(numberOfOutputKernels).toWeight * 0.1...

    you need add import :

    import com.thoughtworks.deeplearning.Poly.MathMethods.*
import com.thoughtworks.deeplearning.DifferentiableINDArray._

    If the compiler shows error:

    not found: value log -(label * log(score * 0.9 + 0.1) + (1.0 - label) * log(1.0 - score * 0.9)).mean...

    you need add import:

    import com.thoughtworks.deeplearning.Poly.MathFunctions.*
import com.thoughtworks.deeplearning.DifferentiableINDArray._

    Those + - * / and log exp abs max min are defined at MathMethods and MathFunctions，those method are been implemented at DifferentiableType，so you need to import the implicit of DifferentiableType.

    Composability

    Neural networks created by DeepLearning.scala are composable. You can create large networks by combining smaller networks. If two larger networks share some sub-networks, the weights in shared sub-networks trained with one network affect the other network.

    Definition Classes
    thoughtworks
    See also

    Compose

  • object Poly

    A namespace of common math operators.

    A namespace of common math operators.

    MathMethods and MathFunctions provide functions like +, -, *, /, log, abs, max, min and exp, those functions been implements in specific Differentiable Object such as DifferentiableINDArray

    Author:

    杨博 (Yang Bo) <[email protected]>

    Definition Classes
    deeplearning
    See also

    DifferentiableINDArray.exp(INDArray)

    DifferentiableINDArray.Double+INDArray

  • LayerPoly1
  • LayerPoly2
  • MathFunctions
  • MathMethods
  • MathOps

trait LayerPoly1 extends Poly1

A unary polymorphic function that accepts some kind of Layers or values able to convert to those kind of layers.

See also

https://github.com/milessabin/shapeless/wiki/Feature-overview:-shapeless-2.0.0#polymorphic-function-values

Linear Supertypes
Poly1, shapeless.Poly, Serializable, Serializable, PolyApply, AnyRef, Any
Known Subclasses
abs, exp, log
Type Hierarchy
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 StringFormat
  26. by Ensuring
  27. by ArrowAssoc
  1. Hide All
  2. Show All
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
  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: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def *[Right](right: Right)(implicit methodCase: MathMethods.*.Case[LayerPoly1, Right]): Result
    Implicit
    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
  4. def +[Right](right: Right)(implicit methodCase: MathMethods.+.Case[LayerPoly1, Right]): Result
    Implicit
    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 +(other: String): String
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to any2stringadd[LayerPoly1] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  6. def -[Right](right: Right)(implicit methodCase: MathMethods.-.Case[LayerPoly1, Right]): Result
    Implicit
    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
  7. def ->[B](y: B): (LayerPoly1, B)
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to ArrowAssoc[LayerPoly1] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  8. def /[Right](right: Right)(implicit methodCase: MathMethods./.Case[LayerPoly1, Right]): Result
    Implicit
    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
  9. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. def andThen(f: shapeless.Poly): Compose[f.type, LayerPoly1.this.type]
    Definition Classes
    Poly
  11. def apply[R](implicit c: Aux[HNil, R]): R
    Definition Classes
    Poly
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. 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
  31. 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
  32. def apply[A, B](a: A, b: B)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, ::[B, HNil]]]): Result
    Definition Classes
    PolyApply
  33. def apply[A](a: A)(implicit cse: shapeless.PolyDefns.Case[LayerPoly1.this.type, ::[A, HNil]]): Result
    Definition Classes
    PolyApply
  34. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  35. def at[A]: CaseBuilder[A]
    Definition Classes
    Poly1
  36. def caseAt[L <: HList](implicit c: ProductCase[L]): ProductCase[L]
    Definition Classes
    Poly
  37. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  38. def compose(f: shapeless.Poly): Compose[LayerPoly1.this.type, f.type]
    Definition Classes
    Poly
  39. def ensuring(cond: (LayerPoly1) ⇒ Boolean, msg: ⇒ Any): LayerPoly1
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  40. def ensuring(cond: (LayerPoly1) ⇒ Boolean): LayerPoly1
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  41. def ensuring(cond: Boolean, msg: ⇒ Any): LayerPoly1
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  42. def ensuring(cond: Boolean): LayerPoly1
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to Ensuring[LayerPoly1] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  43. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  44. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  45. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  46. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to StringFormat[LayerPoly1] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  47. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  48. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  49. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  50. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  51. final def notify(): Unit
    Definition Classes
    AnyRef
  52. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  53. def rotateLeft[N <: Nat]: RotateLeft[LayerPoly1.this.type, N]
    Definition Classes
    Poly
  54. def rotateRight[N <: Nat]: RotateRight[LayerPoly1.this.type, N]
    Definition Classes
    Poly
  55. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  56. implicit def toLayerCase[Operand, Input <: Tape, OperandData, OperandDelta](implicit toLayer: Aux[Operand, Input, OperandData, OperandDelta], layerCase: Lazy[Case[Aux[Input, Aux[OperandData, OperandDelta]]]]): Aux[Operand, Result]
  57. def toString(): String
    Definition Classes
    AnyRef → Any
  58. def use[T, L <: HList, R](t: T)(implicit cb: LayerPoly1.CaseBuilder[T, L, R]): Aux[L, R]
    Definition Classes
    Poly
  59. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  60. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  61. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  62. def →[B](y: B): (LayerPoly1, B)
    Implicit
    This member is added by an implicit conversion from LayerPoly1 to ArrowAssoc[LayerPoly1] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
  63. object Case
    Definition Classes
    Poly1

Shadowed Implicit Value Members

  1. def andThen[A](g: (Result) ⇒ A): (A) ⇒ A
    Implicit
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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. def toString(): String
    Implicit
    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
  47. def toString(): String
    Implicit
    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
  48. def toString(): String
    Implicit
    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
  49. def toString(): String
    Implicit
    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
  50. def toString(): String
    Implicit
    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
  51. def toString(): String
    Implicit
    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
  52. def toString(): String
    Implicit
    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
  53. def toString(): String
    Implicit
    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
  54. def toString(): String
    Implicit
    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
  55. def toString(): String
    Implicit
    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
  56. def toString(): String
    Implicit
    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
  57. def toString(): String
    Implicit
    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
  58. def toString(): String
    Implicit
    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
  59. def toString(): String
    Implicit
    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
  60. def toString(): String
    Implicit
    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
  61. def toString(): String
    Implicit
    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
  62. def toString(): String
    Implicit
    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
  63. def toString(): String
    Implicit
    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
  64. def toString(): String
    Implicit
    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
  65. def toString(): String
    Implicit
    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
  66. def toString(): String
    Implicit
    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
  67. def toString(): String
    Implicit
    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
  68. 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
    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()
  69. 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
    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()
  70. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) ⇒ Result
    Implicit
    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()
  71. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Result
    Implicit
    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()
  72. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) ⇒ Result
    Implicit
    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()
  73. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) ⇒ Result
    Implicit
    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()
  74. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Result
    Implicit
    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()
  75. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) ⇒ Result
    Implicit
    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()
  76. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N)) ⇒ Result
    Implicit
    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()
  77. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L, M)) ⇒ Result
    Implicit
    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()
  78. def tupled: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Result
    Implicit
    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()
  79. def tupled: ((A, B, C, D, E, F, G, H, I, J, K)) ⇒ Result
    Implicit
    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()
  80. def tupled: ((A, B, C, D, E, F, G, H, I, J)) ⇒ Result
    Implicit
    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()
  81. def tupled: ((A, B, C, D, E, F, G, H, I)) ⇒ Result
    Implicit
    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()
  82. def tupled: ((A, B, C, D, E, F, G, H)) ⇒ Result
    Implicit
    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()
  83. def tupled: ((A, B, C, D, E, F, G)) ⇒ Result
    Implicit
    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()
  84. def tupled: ((A, B, C, D, E, F)) ⇒ Result
    Implicit
    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()
  85. def tupled: ((A, B, C, D, E)) ⇒ Result
    Implicit
    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()
  86. def tupled: ((A, B, C, D)) ⇒ Result
    Implicit
    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()
  87. def tupled: ((A, B, C)) ⇒ Result
    Implicit
    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()
  88. def tupled: ((A, B)) ⇒ Result
    Implicit
    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()

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 any2stringadd[LayerPoly1]

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

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

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

Ungrouped