Packages

p

skunk

package skunk

Linear Supertypes
TwiddleCompat, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. skunk
  2. TwiddleCompat
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type *:[A, B <: Tuple] = ::[A, B]
    Definition Classes
    TwiddleCompat
  2. type EmptyTuple = HNil
    Definition Classes
    TwiddleCompat
  3. type SessionPool[F[_]] = Resource[F, Resource[F, Session[F]]]
  4. type Strategy = skunk.util.Typer.Strategy
  5. type Tuple = HList
    Definition Classes
    TwiddleCompat
  6. type ~[+A, +B] = (A, B)

Value Members

  1. val *:: ::.type
    Definition Classes
    TwiddleCompat
    Annotations
    @inline()
  2. val EmptyTuple: EmptyTuple
    Definition Classes
    TwiddleCompat
    Annotations
    @inline()
  3. val Strategy: skunk.util.Typer.Strategy.type
  4. val Tuple: HList.type
    Definition Classes
    TwiddleCompat
    Annotations
    @inline()
  5. implicit def hlistToTuple[L <: Tuple, T](l: L)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[L, T]): T
    Definition Classes
    TwiddleCompat
  6. implicit def toTupleOps[T <: Tuple](t: T): TupleOps[T]
    Definition Classes
    TwiddleCompat
  7. implicit def tuple10ToHList[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, EmptyTuple]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  8. implicit def tuple11ToHList[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, EmptyTuple]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  9. implicit def tuple12ToHList[A, B, C, D, E, F, G, H, I, J, K, L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, EmptyTuple]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  10. implicit def tuple13ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M](t: (A, B, C, D, E, F, G, H, I, J, K, L, M)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, EmptyTuple]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  11. implicit def tuple14ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, EmptyTuple]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  12. implicit def tuple15ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, EmptyTuple]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  13. implicit def tuple16ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, EmptyTuple]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  14. implicit def tuple17ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, EmptyTuple]]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  15. implicit def tuple18ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, EmptyTuple]]]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  16. implicit def tuple19ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, EmptyTuple]]]]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  17. implicit def tuple20ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, *:[T, EmptyTuple]]]]]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  18. implicit def tuple21ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, *:[T, *:[U, EmptyTuple]]]]]]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  19. implicit def tuple22ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, *:[T, *:[U, *:[V, EmptyTuple]]]]]]]]]]]]]]]]]]]]]]
    Definition Classes
    TwiddleCompat
  20. implicit def tuple2ToHList[A, B](t: (A, B)): *:[A, *:[B, EmptyTuple]]
    Definition Classes
    TwiddleCompat
  21. implicit def tuple3ToHList[A, B, C](t: (A, B, C)): *:[A, *:[B, *:[C, EmptyTuple]]]
    Definition Classes
    TwiddleCompat
  22. implicit def tuple4ToHList[A, B, C, D](t: (A, B, C, D)): *:[A, *:[B, *:[C, *:[D, EmptyTuple]]]]
    Definition Classes
    TwiddleCompat
  23. implicit def tuple5ToHList[A, B, C, D, E](t: (A, B, C, D, E)): *:[A, *:[B, *:[C, *:[D, *:[E, EmptyTuple]]]]]
    Definition Classes
    TwiddleCompat
  24. implicit def tuple6ToHList[A, B, C, D, E, F](t: (A, B, C, D, E, F)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, EmptyTuple]]]]]]
    Definition Classes
    TwiddleCompat
  25. implicit def tuple7ToHList[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, EmptyTuple]]]]]]]
    Definition Classes
    TwiddleCompat
  26. implicit def tuple8ToHList[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, EmptyTuple]]]]]]]]
    Definition Classes
    TwiddleCompat
  27. implicit def tuple9ToHList[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, EmptyTuple]]]]]]]]]
    Definition Classes
    TwiddleCompat

Inherited from TwiddleCompat

Inherited from AnyRef

Inherited from Any

Ungrouped