PolyDefns

Type Members

class ->[T, R] extends Poly1

Base class for lifting a Function1 to a Poly1
class >->[T, R] extends LowPriorityLiftFunction1

Base class for lifting a Function1 to a Poly1 over the universal domain, yielding an HList with the result as its only element if the argument is in the original functions domain, HNil otherwise.
abstract class Case[P, L <: HList] extends AnyRef

Type-specific case of a polymorphic function.
type Case0[P] = Case[P, HNil]
type Case1[Fn, A] = Case[Fn, ::[A, HNil]]

Definition Classes
Cases
type Case10[Fn, A, B, C, D, E, F, G, H, I, J] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]]

Definition Classes
Cases
type Case11[Fn, A, B, C, D, E, F, G, H, I, J, K] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]]

Definition Classes
Cases
type Case12[Fn, A, B, C, D, E, F, G, H, I, J, K, L] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]]

Definition Classes
Cases
type Case13[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]]

Definition Classes
Cases
type Case14[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case15[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case16[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case17[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case18[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case19[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case2[Fn, A, B] = Case[Fn, ::[A, ::[B, HNil]]]

Definition Classes
Cases
type Case20[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case21[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case22[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]]

Definition Classes
Cases
type Case3[Fn, A, B, C] = Case[Fn, ::[A, ::[B, ::[C, HNil]]]]

Definition Classes
Cases
type Case4[Fn, A, B, C, D] = Case[Fn, ::[A, ::[B, ::[C, ::[D, HNil]]]]]

Definition Classes
Cases
type Case5[Fn, A, B, C, D, E] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]]

Definition Classes
Cases
type Case6[Fn, A, B, C, D, E, F] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]]

Definition Classes
Cases
type Case7[Fn, A, B, C, D, E, F, G] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]]

Definition Classes
Cases
type Case8[Fn, A, B, C, D, E, F, G, H] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]]

Definition Classes
Cases
type Case9[Fn, A, B, C, D, E, F, G, H, I] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]

Definition Classes
Cases
class Compose[F, G] extends Poly

Represents the composition of two polymorphic function values.
class LiftU[P <: Poly] extends LowPriorityLiftU

Base class for lifting a Poly to a Poly over the universal domain, yielding an HList with the result as it's only element if the argument is in the original functions domain, HNil otherwise.
trait LowPriorityLiftFunction1 extends Poly1
trait LowPriorityLiftU extends Poly
trait ~>[F[_], G[_]] extends Poly1

Base trait for natural transformations.
type ~>>[F[_], R] = ~>[F, [T]R]

Natural transformation with a constant type constructor on the right hand side.

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
object Case extends CaseInst
object Case0
object Case1

Definition Classes
Cases
object Case10

Definition Classes
Cases
object Case11

Definition Classes
Cases
object Case12

Definition Classes
Cases
object Case13

Definition Classes
Cases
object Case14

Definition Classes
Cases
object Case15

Definition Classes
Cases
object Case16

Definition Classes
Cases
object Case17

Definition Classes
Cases
object Case18

Definition Classes
Cases
object Case19

Definition Classes
Cases
object Case2

Definition Classes
Cases
object Case20

Definition Classes
Cases
object Case21

Definition Classes
Cases
object Case22

Definition Classes
Cases
object Case3

Definition Classes
Cases
object Case4

Definition Classes
Cases
object Case5

Definition Classes
Cases
object Case6

Definition Classes
Cases
object Case7

Definition Classes
Cases
object Case8

Definition Classes
Cases
object Case9

Definition Classes
Cases
object Compose
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
object identity extends ~>[Id, Id]

Polymorphic identity function.
final def isInstanceOf[T0]: Boolean

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
object ~>

Related Doc: package shapeless

object PolyDefns extends Cases

Type Members

class ->[T, R] extends Poly1

class >->[T, R] extends LowPriorityLiftFunction1

abstract class Case[P, L <: HList] extends AnyRef

type Case0[P] = Case[P, HNil]

type Case1[Fn, A] = Case[Fn, ::[A, HNil]]

type Case10[Fn, A, B, C, D, E, F, G, H, I, J] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, HNil]]]]]]]]]]]

type Case11[Fn, A, B, C, D, E, F, G, H, I, J, K] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, HNil]]]]]]]]]]]]

type Case12[Fn, A, B, C, D, E, F, G, H, I, J, K, L] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, HNil]]]]]]]]]]]]]

type Case13[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, HNil]]]]]]]]]]]]]]

type Case14[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, HNil]]]]]]]]]]]]]]]

type Case15[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, HNil]]]]]]]]]]]]]]]]

type Case16[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, HNil]]]]]]]]]]]]]]]]]

type Case17[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, HNil]]]]]]]]]]]]]]]]]]

type Case18[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]]

type Case19[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, HNil]]]]]]]]]]]]]]]]]]]]

type Case2[Fn, A, B] = Case[Fn, ::[A, ::[B, HNil]]]

type Case20[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, HNil]]]]]]]]]]]]]]]]]]]]]

type Case21[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, HNil]]]]]]]]]]]]]]]]]]]]]]

type Case22[Fn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, ::[S, ::[T, ::[U, ::[V, HNil]]]]]]]]]]]]]]]]]]]]]]]

type Case3[Fn, A, B, C] = Case[Fn, ::[A, ::[B, ::[C, HNil]]]]

type Case4[Fn, A, B, C, D] = Case[Fn, ::[A, ::[B, ::[C, ::[D, HNil]]]]]

type Case5[Fn, A, B, C, D, E] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, HNil]]]]]]

type Case6[Fn, A, B, C, D, E, F] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, HNil]]]]]]]

type Case7[Fn, A, B, C, D, E, F, G] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, HNil]]]]]]]]

type Case8[Fn, A, B, C, D, E, F, G, H] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, HNil]]]]]]]]]

type Case9[Fn, A, B, C, D, E, F, G, H, I] = Case[Fn, ::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]

class Compose[F, G] extends Poly

class LiftU[P <: Poly] extends LowPriorityLiftU

trait LowPriorityLiftFunction1 extends Poly1

trait LowPriorityLiftU extends Poly

trait ~>[F[_], G[_]] extends Poly1

type ~>>[F[_], R] = ~>[F, [T]R]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Case extends CaseInst

object Case0

object Case1

object Case10

object Case11

object Case12

object Case13

object Case14

object Case15

object Case16

object Case17

object Case18

object Case19

object Case2

object Case20

object Case21

object Case22

object Case3

object Case4

object Case5

object Case6

object Case7

object Case8

object Case9

object Compose

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

object identity extends ~>[Id, Id]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit