shapeless

Type Members

sealed trait :+:[+H, +T <: Coproduct] extends Coproduct
final case class ::[+H, +T <: HList](head: H, tail: T) extends HList with Product with Serializable

Non-empty HList element type.
trait <:!<[A, B] extends AnyRef
trait =:!=[A, B] extends AnyRef
trait AdditiveCollection[Repr] extends Serializable

Evidence that Repr instances can be nested in a Sized.
Evidence that Repr instances can be nested in a Sized.
Should assert that a Builder[_, Repr] given n elements will result in a Repr of length n.
class ApplyEverything[F <: Poly] extends AnyRef
trait ApplyUnapplyFacet extends ProductISOFacet
trait BasisConstraint[L <: HList, M <: HList] extends Serializable

Type class witnessing that every element of L is an element of M.
sealed trait CNil extends Coproduct
class CachedImplicitMacros extends AnyRef
trait CaseClassFacet extends AnyRef
trait CaseClassMacros extends ReprTypes
trait CaseInst extends AnyRef
trait Cases extends AnyRef
type Const[C] = AnyRef { type λ[T] = C }

sealed trait Coproduct extends AnyRef

Encodes a coproduct type, such as a sealed family of case classes.

Each constructor from the family gets an encoding in terms of nested Inr and Inl.

Which constructor is encoded as Inl() and which as Inr(Inl()) is determined by lexical order of the subclasses. This example illustrates the encoding:

scala> sealed trait Animal
defined trait Animal

scala> case class Cat(name: String, livesLeft: Int) extends Animal
defined class Cat

scala> case class Dog(name: String, bonesBuried: Int) extends Animal
defined class Dog

scala> case class Koala(name: String, leavesEaten: Int) extends Animal
defined class Koala

scala> case class Sloth(name: String, daysToClimbDownFromCurrentTree: Int) extends Animal
defined class Sloth

scala> val garfield = Cat("Garfield", 9)
garfield: Cat = Cat(Garfield,9)

scala> val odie = Dog("Odie", 3)
odie: Dog = Dog(Odie,3)

scala> val koala = Koala("foo", 10)
koala: Koala = Koala(foo,10)

scala> val sloth = Sloth("bar", 2)
sloth: Sloth = Sloth(bar,2)

scala> val genAnimal = Generic[Animal]
genAnimal: shapeless.Generic[Animal]{type Repr = Cat :+: Dog :+: Koala :+: Sloth} = ...

scala> def showCoproduct(o: Any) : String = o match {
     | case Inl(a) => "Inl(" + showCoproduct(a) + ")"
     | case Inr(a) => "Inr(" + showCoproduct(a) + ")"
     | case a => a.toString
     | }
showCoproduct: (o: Any)String

scala> showCoproduct(genAnimal.to(garfield))
res5: String = Inl(Cat(Garfield,9))

scala> showCoproduct(genAnimal.to(odie))
res6: String = Inr(Inl(Dog(Odie,3)))

scala> showCoproduct(genAnimal.to(koala))
res7: String = Inr(Inr(Inl(Koala(foo,10))))

scala> showCoproduct(genAnimal.to(sloth))
res8: String = Inr(Inr(Inr(Inl(Sloth(bar,2)))))

scala>

trait CopyFacet extends CaseClassFacet
trait Coselect[T] extends AnyRef
trait Data[F, T, R] extends Serializable

Type class representing one-level generic queries.
trait Data0 extends AnyRef
trait Data1 extends Data0
trait DataT[F, T] extends Serializable

Type class representing one-level generic transformations.
trait DataT0 extends AnyRef
trait DataT1 extends DataT0
trait DefaultCaseClassDefns extends ApplyUnapplyFacet with ProductFacet with PolymorphicEqualityFacet with CopyFacet with ToStringFacet
trait DefaultSymbolicLabelling[T] extends DepFn0 with Serializable
trait DepFn0 extends AnyRef

Dependent nullary function type.
trait DepFn1[T] extends AnyRef

Dependent unary function type.
trait DepFn2[T, U] extends AnyRef

Dependent binary function type.
trait DerivationContext extends CaseClassMacros
type Everything[F <: Poly, K <: Poly, T] = Case[EverythingAux[F, K], ::[T, HNil]]

The SYB everything combinator
class EverythingAux[F, K] extends Poly
type Everywhere[F <: Poly, T] = Case[EverywhereAux[F], ::[T, HNil]]

The SYB everywhere combinator
class EverywhereAux[F] extends Poly
trait FieldOf[V] extends AnyRef

Field with values of type V.
Field with values of type V.
Record keys of this form should be objects which extend this trait. Keys may also be arbitrary singleton typed values, however keys of this form enforce the type of their values.
trait FieldPoly extends Poly1

Polymorphic function that allows modifications on record fields while preserving the original key types.
trait Fin[N <: Succ[_]] extends AnyRef

Base trait for type level finite numbers, i.e.
Base trait for type level finite numbers, i.e. numbers less than some bound N
case class FinSucc[N <: Succ[_], P <: Fin[N]]() extends Fin[Succ[N]] with Product with Serializable

Encoding of successor.
case class FinZero[N <: Succ[_]]() extends Fin[N] with Product with Serializable

Encoding of zero.
trait Generic[T] extends Serializable

Represents the ability to convert from a concrete type (e.g.
Represents the ability to convert from a concrete type (e.g. a case class) to a generic (HList / Coproduct} based) representation of the type.
For example:
```
scala> sealed trait Animal

defined trait Animal
scala> case class Cat(name: String, livesLeft: Int) extends Animal
defined class Cat

scala> case class Dog(name: String, bonesHidden: Int) extends Animal
defined class Dog

scala> val genCat = Generic[Cat]
genCat: shapeless.Generic[Cat]{ type Repr = String :: Int :: HNil } = ...

scala> val genDog = Generic[Dog]
genDog: shapeless.Generic[Dog]{ type Repr = String :: Int :: HNil } = ...

scala> val garfield = Cat("Garfield", 9)
garfield: Cat = Cat(Garfield,9)

scala> val genGarfield = genCat.to(garfield)
genGarfield: genCat.Repr = Garfield :: 9 :: HNil

scala> val reconstructed = genCat.from(genGarfield)
reconstructed: Cat = Cat(Garfield,9)

scala> reconstructed == garfield
res0: Boolean = true
```
Note that constituents of Cat and Dog are exactly the same - a String and an Int. So we could do:
```
scala> val odieAsCat = genCat.from(genDog.to(odie))
odieAsCat: Cat = Cat(odie,3)
```
This is quite useful in certain cases, such as copying from one object type to another, as in schema evolution.
Note that the generic representation depends on the type at which we instantiate Generic. In the example above we instantiated it at Cat and at Dog, and so the generic representation gave the minimal constituents of each of those.
However, if we instantiate Generic[Animal] instead the generic representation would encode the Cat-ness or Dog-ness of the instance as well (see Coproduct for details of the encoding):
```
scala> genDog.to(odie)
res9: genDog.Repr = odie :: 3 :: HNil

scala> val genAnimal = Generic[Animal]
genAnimal: shapeless.Generic[Animal]{ type Repr = Cat :+: Dog :+: CNil } = ...

scala> genAnimal.to(odie)
res8: genAnimal.Repr = Dog(odie,3)

scala> genAnimal.to(odie) match { case Inr(Inl(dog)) => dog; case _ => null }
res9: Dog = Dog(odie,3)
```
Inr and Inl are shapeless.Coproduct constructors. Shapeless constructs each class representation as a sort of "nested Either" using Coproduct. So in our example, genAnimal would essentially encode garfield as Inl(garfield) and odie as Inr(Inl(odie)). Please see shapeless.Coproduct for more details. }}}
T
An immutable data type that has a canonical way of constructing and deconstructing instances (e.g. via apply / unapply). Sealed families of case classes work best.
trait Generic1[F[_], FR[_[_]]] extends Serializable
class Generic1Macros extends CaseClassMacros
class GenericMacros extends CaseClassMacros
sealed trait HList extends Product with Serializable

HList ADT base trait.
class HMap[R[_, _]] extends Poly1

Heterogenous map with type-level key/value associations that are fixed by an arbitrary relation R.
Heterogenous map with type-level key/value associations that are fixed by an arbitrary relation R.
HMaps extend Poly and hence are also polymorphic function values with type-specific cases corresponding to the map's type-level key/value associations.
class HMapBuilder[R[_, _]] extends AnyRef
sealed trait HNil extends HList

Empty HList element type.
trait HasCoproductGeneric[T] extends Serializable
trait HasProductGeneric[T] extends Serializable
type Id[+T] = T
trait InferProduct[C <: Coproduct, K] extends AnyRef
final case class Inl[+H, +T <: Coproduct](head: H) extends :+:[H, T] with Product with Serializable
final case class Inr[+H, +T <: Coproduct](tail: T) extends :+:[H, T] with Product with Serializable
trait IsCCons1[L[_], FH[_[_]], FT[_[_]]] extends AnyRef
class IsCCons1Macros extends IsCons1Macros
trait IsCons1Macros extends CaseClassMacros
trait IsHCons1[L[_], FH[_[_]], FT[_[_]]] extends AnyRef
class IsHCons1Macros extends IsCons1Macros
trait IsTuple[T] extends Serializable
trait KeyConstraint[L <: HList, M <: HList] extends Serializable

Type class witnessing that every element of L is of the form FieldType[K, V] where K is an element of M.
trait LUBConstraint[L <: HList, B] extends Serializable

Type class witnessing that every element of L is a subtype of B.
trait LabelledGeneric[T] extends Generic[T]

LabelledGeneric is similar to Generic, but includes information about field names or class names in addition to the raw structure.
LabelledGeneric is similar to Generic, but includes information about field names or class names in addition to the raw structure.
Continuing the example from shapeless.Generic, we use LabelledGeneric to convert an object to an shapeless.HList:
```
scala> val lgenDog = LabelledGeneric[Dog]
lgenDog: shapeless.LabelledGeneric[Dog]{ type Repr = Record.`'name -> String, 'bonesHidden -> Int`.T } = ...

scala> lgenDog.to(odie)
res15: lgenDog.Repr = odie :: 3 :: HNil
```
Note that the representation does not include the labels! The labels are actually encoded in the generic type representation using shapeless.Witness types.
As with shapeless.Generic, the representation for Animal captures the subclass embedding rather than the fields in the class, using shapeless.Coproduct:
```
scala> val lgenAnimal = LabelledGeneric[Animal]
lgenAnimal: shapeless.LabelledGeneric[Animal]{ type Repr = Union.`'Cat -> Cat, 'Dog -> Dog`.T } = ...

scala> lgenAnimal.to(odie)
res16: lgenAnimal.Repr = Dog(odie,3)

scala> genAnimal.to(odie) match { case Inr(Inl(dog)) => dog ; case _ => ???}
res19: Dog = Dog(odie,3)
```
T
the type which this instance can convert to and from a labelled generic representation
class LabelledMacros extends SingletonTypeUtils with CaseClassMacros
trait LabelledProductTypeClass[C[_]] extends Serializable

A type class abstracting over the product operation of type classes over types of kind *, as well as deriving instances using an isomorphism.
A type class abstracting over the product operation of type classes over types of kind *, as well as deriving instances using an isomorphism. Refines ProductTypeClass with the addition of runtime String labels corresponding to the names of the product elements.
trait LabelledProductTypeClassCompanion[C[_]] extends Serializable
trait LabelledTypeClass[C[_]] extends LabelledProductTypeClass[C]

A type class additionally abstracting over the coproduct operation of type classes over types of kind *.
A type class additionally abstracting over the coproduct operation of type classes over types of kind *.
Name hints can be safely ignored.
trait LabelledTypeClassCompanion[C[_]] extends LabelledProductTypeClassCompanion[C]
trait Lazy[+T] extends Serializable
class LazyMacros extends AnyRef
trait Lens[S, A] extends Dynamic with Serializable
trait LowPriorityMkPathOptic extends AnyRef
trait LowPriorityMkSelectDynamicOptic extends AnyRef
trait LowPrioritySegment extends AnyRef
trait LowPrioritySized extends AnyRef
trait LowPriorityTypeable extends AnyRef
trait LowPriorityWitnessWith extends AnyRef
trait Lub[-A, -B, Out] extends Serializable

Type class witnessing the least upper bound of a pair of types and providing conversions from each to their common supertype.
trait MkCoproductSelectPrism[C <: Coproduct, T] extends Serializable
trait MkCtorPrism[A, B] extends AnyRef
trait MkFieldLens[A, K] extends AnyRef
trait MkGenericLens[T] extends Serializable
trait MkHListNthLens[L <: HList, N <: Nat] extends Serializable
trait MkHListSelectLens[L <: HList, U] extends Serializable
trait MkLabelledGenericLens[T] extends Serializable
trait MkNthFieldLens[A, N <: Nat] extends AnyRef
trait MkPathOptic[S, P <: HList] extends AnyRef
trait MkRecordSelectLens[R <: HList, K] extends Serializable
trait MkSelectDynamicOptic[R, A, K, B] extends AnyRef
trait Nat extends AnyRef

Base trait for type level natural numbers.
trait Nats extends AnyRef
trait OpticComposer[L, R] extends AnyRef
case class Orphan[F[_], D, T](instance: F[T]) extends Product with Serializable
trait OrphanDeriver[F[_], D] extends AnyRef
class OrphanMacros extends CaseClassMacros
trait Path[T <: HList] extends Dynamic
trait Poly extends PolyApply with Serializable

Base trait for polymorphic values.
trait Poly0 extends Poly

Trait simplifying the creation of polymorphic values.
trait Poly1 extends Poly
trait Poly10 extends Poly
trait Poly11 extends Poly
trait Poly12 extends Poly
trait Poly13 extends Poly
trait Poly14 extends Poly
trait Poly15 extends Poly
trait Poly16 extends Poly
trait Poly17 extends Poly
trait Poly18 extends Poly
trait Poly19 extends Poly
trait Poly2 extends Poly
trait Poly20 extends Poly
trait Poly21 extends Poly
trait Poly22 extends Poly
trait Poly3 extends Poly
trait Poly4 extends Poly
trait Poly5 extends Poly
trait Poly6 extends Poly
trait Poly7 extends Poly
trait Poly8 extends Poly
trait Poly9 extends Poly
trait PolyApply extends AnyRef
trait PolyInst extends AnyRef
class PolyMacros extends AnyRef
trait PolymorphicEqualityFacet extends ProductISOFacet
trait Prism[S, A] extends Dynamic with Serializable
trait ProductArgs extends Dynamic

Trait supporting mapping dynamic argument lists to HList arguments.
Trait supporting mapping dynamic argument lists to HList arguments.
Mixing in this trait enables method applications of the form,
```
lhs.method(23, "foo", true)
```
to be rewritten as,
```
lhs.methodProduct(23 :: "foo" :: true)
```
ie. the arguments are rewritten as HList elements and the application is rewritten to an application of an implementing method (identified by the "Product" suffix) which accepts a single HList argument.
trait ProductFacet extends ProductISOFacet
trait ProductISOFacet extends CaseClassFacet
trait ProductLensBuilder[C, P <: Product] extends Lens[C, P]
class ProductMacros extends SingletonTypeUtils
trait ProductPrismBuilder[C, P <: Product] extends Prism[C, P]
trait ProductTypeClass[C[_]] extends Serializable

A type class abstracting over the product operation of type classes over types of kind *, as well as deriving instances using an isomorphism.
trait ProductTypeClassCompanion[C[_]] extends Serializable
trait RecordArgs extends Dynamic

Trait supporting mapping named argument lists to record arguments.
Trait supporting mapping named argument lists to record arguments.
Mixing in this trait enables method applications of the form,
```
lhs.method(x = 23, y = "foo", z = true)
```
to be rewritten as,
```
lhs.methodRecord('x ->> 23 :: 'y ->> "foo", 'z ->> true)
```
ie. the named arguments are rewritten as record fields with the argument name encoded as a singleton-typed Symbol and the application is rewritten to an application of an implementing method (identified by the "Record" suffix) which accepts a single record argument.
class RecordMacros extends AnyRef
trait ReprTypes extends AnyRef
trait Segment[P, S, T <: HList] extends AnyRef
trait Select[T] extends AnyRef
trait SingletonProductArgs extends Dynamic

Trait supporting mapping dynamic argument lists to singleton-typed HList arguments.
Trait supporting mapping dynamic argument lists to singleton-typed HList arguments.
Mixing in this trait enables method applications of the form,
```
lhs.method(23, "foo", true)
```
to be rewritten as,
```
lhs.methodProduct(23.narrow :: "foo".narrow :: true.narrow)
```
ie. the arguments are rewritten as singleton-typed HList elements and the application is rewritten to an application of an implementing method (identified by the "Product" suffix) which accepts a single HList argument.
class SingletonTypeMacros extends SingletonTypeUtils
trait SingletonTypeUtils extends ReprTypes
final class Sized[+Repr, L <: Nat] extends AnyVal

Wrapper for a collection type witnessing that it has the statically specified length.
Wrapper for a collection type witnessing that it has the statically specified length. Can be applied to any type which can be viewed as a GenTraversableLike, ie. standard collections, Arrays, Strings etc.
class SizedBuilder[CC[_]] extends AnyRef
class SizedOps[A0, Repr, L <: Nat] extends AnyRef

Carrier for Sized operations.
Carrier for Sized operations.
These operations are implemented here as extension methods of the minimal Sized type to avoid issues that would otherwise be caused by its covariance.
trait Split1[L[_], FO[_[_]], FI[_[_]]] extends AnyRef
class Split1Macros extends AnyRef
case class Succ[P <: Nat]() extends Nat with Product with Serializable

Encoding of successor.
trait ToStringFacet extends ProductFacet
trait TupleTypeableInstances extends AnyRef
trait TypeCase[T] extends Serializable

Extractor for use of Typeable in pattern matching.
Extractor for use of Typeable in pattern matching.
Thanks to Stacy Curl for the idea.
trait TypeClass[C[_]] extends ProductTypeClass[C]

A type class additionally abstracting over the coproduct operation of type classes over types of kind *.
trait TypeClassCompanion[C[_]] extends ProductTypeClassCompanion[C]
trait Typeable[T] extends Serializable

Type class supporting type safe cast.
class TypeableMacros extends SingletonTypeUtils
trait UnaryTCConstraint[L <: HList, TC[_]] extends Serializable

Type class witnessing that every element of L has TC as its outer type constructor.
class UnionMacros extends AnyRef
trait Unpack1[-PP, FF[_], A] extends AnyRef

Type class witnessing that type PP is equal to FF[A] for some higher kinded type FF[_] and type(s) A.
trait Unpack10[-PP, FF[_, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J.
trait Unpack11[-PP, FF[_, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K.
trait Unpack12[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L.
trait Unpack13[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M.
trait Unpack14[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N.
trait Unpack15[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O.
trait Unpack16[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P.
trait Unpack17[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q.
trait Unpack18[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R.
trait Unpack19[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S.
trait Unpack2[-PP, FF[_, _], A, B] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B] for some higher kinded type FF[_, _] and type(s) A, B.
trait Unpack20[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T.
trait Unpack21[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U.
trait Unpack22[-PP, FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] for some higher kinded type FF[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V.
trait Unpack3[-PP, FF[_, _, _], A, B, C] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C] for some higher kinded type FF[_, _, _] and type(s) A, B, C.
trait Unpack4[-PP, FF[_, _, _, _], A, B, C, D] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D] for some higher kinded type FF[_, _, _, _] and type(s) A, B, C, D.
trait Unpack5[-PP, FF[_, _, _, _, _], A, B, C, D, E] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E] for some higher kinded type FF[_, _, _, _, _] and type(s) A, B, C, D, E.
trait Unpack6[-PP, FF[_, _, _, _, _, _], A, B, C, D, E, F] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F] for some higher kinded type FF[_, _, _, _, _, _] and type(s) A, B, C, D, E, F.
trait Unpack7[-PP, FF[_, _, _, _, _, _, _], A, B, C, D, E, F, G] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G] for some higher kinded type FF[_, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G.
trait Unpack8[-PP, FF[_, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H] for some higher kinded type FF[_, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H.
trait Unpack9[-PP, FF[_, _, _, _, _, _, _, _, _], A, B, C, D, E, F, G, H, I] extends AnyRef

Type class witnessing that type PP is equal to FF[A, B, C, D, E, F, G, H, I] for some higher kinded type FF[_, _, _, _, _, _, _, _, _] and type(s) A, B, C, D, E, F, G, H, I.
trait ValueConstraint[L <: HList, M <: HList] extends Serializable

Type class witnessing that every element of L is of the form FieldType[K, V] where V is an element of M.
trait Witness extends Serializable
trait WitnessWith[TC[_]] extends Witness
case class WrappedOrphan[T](instance: T) extends Product with Serializable
case class Zipper[C, L <: HList, R <: HList, P](prefix: L, suffix: R, parent: P) extends Product with Serializable

Generic Zipper for any type with a representation via Generic.
class _0 extends Nat with Serializable

Encoding of zero.
class nonGeneric extends Annotation with StaticAnnotation
type |¬|[T] = AnyRef { type λ[U] = shapeless.package.<:!<[U,T] }
type |∨|[T, U] = AnyRef { type λ[X] = <:<[shapeless.package.¬¬[X],shapeless.package.∨[T,U]] }
class ~?>[K[_], V[_]] extends Serializable

Type class witnessing the existence of a natural transformation between K[_] and V[_].
Type class witnessing the existence of a natural transformation between K[_] and V[_].
Use this trait to represent an HMap relation of the form K[T] maps to V[T].
type ¬[T] = (T) ⇒ Nothing
type ¬¬[T] = (¬[T]) ⇒ Nothing
type ∀[P[_]] = (∃[[X](P[X]) ⇒ Nothing]) ⇒ Nothing
type ∃[P[_]] = P[_]
type ∧[T, U] = T with U
type ∨[T, U] = (∧[¬[T], ¬[U]]) ⇒ Nothing

Value Members

object AdditiveCollection extends Serializable
object BasisConstraint extends Serializable
object BuildInfo extends Product with Serializable
object Coproduct extends Dynamic
object Data extends Data1 with Serializable
object DataT extends DataT1 with Serializable
object DefaultSymbolicLabelling extends Serializable
object DerivationContext
object EverythingAux extends Serializable
object EverywhereAux extends Serializable
object Fin
object Generic extends Serializable

The companion object for the Generic trait provides a way of obtaining a Generic[T] instance for some T.
The companion object for the Generic trait provides a way of obtaining a Generic[T] instance for some T. In addition, it defines Generic.Aux, which is an important implementation technique that can be generally useful.
object Generic1 extends Serializable
object HList extends Dynamic with Serializable
object HMap extends Serializable
object HNil extends HNil with Product with Serializable

Empty HList value.
object HasCoproductGeneric extends Serializable
object HasProductGeneric extends Serializable
object InferProduct
object IsCCons1
object IsHCons1
object IsTuple extends Serializable
object KeyConstraint extends Serializable
object LUBConstraint extends Serializable
object LabelledGeneric extends Serializable
object Lazy extends Serializable
object LazyMacros
object Lub extends Serializable
object MkCoproductSelectPrism extends Serializable
object MkCtorPrism
object MkFieldLens
object MkGenericLens extends Serializable
object MkHListNthLens extends Serializable
object MkHListSelectLens extends Serializable
object MkLabelledGenericLens extends Serializable
object MkNthFieldLens
object MkPathOptic extends LowPriorityMkPathOptic
object MkRecordSelectLens extends Serializable
object MkSelectDynamicOptic extends LowPriorityMkSelectDynamicOptic
object Nat extends Nats

Type level encoding of the natural numbers.
object NatMacros
object OpticComposer
object OpticDefns
object Orphan extends Serializable
object Path extends Path[HNil]
object Poly extends PolyInst with Serializable

Provides implicit conversions from polymorphic function values to monomorphic function values, eg.
Provides implicit conversions from polymorphic function values to monomorphic function values, eg. for use as arguments to ordinary higher order functions.
object PolyDefns extends Cases
object Segment extends LowPrioritySegment
object Sized extends LowPrioritySized
object Split1
object TheMacros
object Tuple
object TypeCase extends Serializable
object Typeable extends TupleTypeableInstances with LowPriorityTypeable with Serializable

Provides instances of Typeable.
Provides instances of Typeable. Also provides an implicit conversion which enhances arbitrary values with a cast[T] method.
object UnaryTCConstraint extends Serializable
object Unpack1
object Unpack10
object Unpack11
object Unpack12
object Unpack13
object Unpack14
object Unpack15
object Unpack16
object Unpack17
object Unpack18
object Unpack19
object Unpack2
object Unpack20
object Unpack21
object Unpack22
object Unpack3
object Unpack4
object Unpack5
object Unpack6
object Unpack7
object Unpack8
object Unpack9
object ValueConstraint extends Serializable
object Witness extends Dynamic with Serializable
object WitnessWith extends LowPriorityWitnessWith with Serializable
object WrappedOrphan extends Serializable
object Zipper extends Serializable
val ^: Path.type
macro def cachedImplicit[T]: T
def everything(f: Poly): ApplyEverything[f.type]
def everywhere(f: Poly): EverywhereAux[f.type]
val fin: Fin.type

'Fin'
object labelled
object lazily
val lens: OpticDefns.type
val nat: Nat.type

Nat literals
implicit def neq[A, B]: =:!=[A, B]
implicit def neqAmbig1[A]: =:!=[A, A]
implicit def neqAmbig2[A]: =:!=[A, A]
object newtype
implicit def nsub[A, B]: <:!<[A, B]
implicit def nsubAmbig1[A, B >: A]: <:!<[A, B]
implicit def nsubAmbig2[A, B >: A]: <:!<[A, B]
package ops
val optic: OpticDefns.type

Optic definitions
val poly: PolyDefns.type

Poly definitions
val prism: OpticDefns.type
object productElements extends Poly1

Higher ranked function which converts products to HLists.
object record

Record operations on HList's with field-like elements.
package syntax
object tag
package test

object the extends Dynamic

An enhanced alternative to Predef.implicitly.

Used as a term the[T] yields the unique implicit value of type T in the current implicit scope, if any. It is a compile time error if there is no such value. Its primary advantage over Predef.implicitly is that it will preserve any refinement that the implicit definition has, resulting in more precisely typed, and hence often more useful, values,

scala> trait Foo { type T ; val t: T }
defined trait Foo

scala> implicit val intFoo: Foo { type T = Int } = new Foo { type T = Int ; val t = 23 }
intFoo: Foo{type T = Int} = $anon$1@6067b682

scala> implicitly[Foo].t  // implicitly loses precision
res0: Foo#T = 23

scala> implicitly[Foo].t+13
<console>:13: error: type mismatch;
 found   : Int(13)
 required: String
              implicitly[Foo].t+13
                                ^

scala> the[Foo].t         // the retains it
res1: Int = 23

scala> the[Foo].t+13
res2: Int = 36

Unlike implicitly, the can also be used in type position, thanks to a trick due to Denys Shabalin (@den_sh) and Eugene Burmako (@xeno_by). Here we use a combination of selectDynamic and backticks to embed a type in a path which appears to the compiler as stable,

scala> val i: implicitly[Foo].T = 23  // syntax error
<console>:1: error: ';' expected but '.' found.
       val i: implicitly[Foo].T = 23
                             ^
scala> val i: the.`Foo`.T = 23        // OK
i: Int = 23

object tupled extends Poly1

Higher ranked function which converts HLists to tuples.
def unexpected: Nothing
object union
object ~?> extends Serializable

package shapeless

Type Members

sealed trait :+:[+H, +T <: Coproduct] extends Coproduct

final case class ::[+H, +T <: HList](head: H, tail: T) extends HList with Product with Serializable

trait <:!<[A, B] extends AnyRef

trait =:!=[A, B] extends AnyRef

trait AdditiveCollection[Repr] extends Serializable

class ApplyEverything[F <: Poly] extends AnyRef

trait ApplyUnapplyFacet extends ProductISOFacet

trait BasisConstraint[L <: HList, M <: HList] extends Serializable

sealed trait CNil extends Coproduct

class CachedImplicitMacros extends AnyRef

trait CaseClassFacet extends AnyRef

trait CaseClassMacros extends ReprTypes

trait CaseInst extends AnyRef

trait Cases extends AnyRef

type Const[C] = AnyRef { type λ[T] = C }

sealed trait Coproduct extends AnyRef

trait CopyFacet extends CaseClassFacet

trait Coselect[T] extends AnyRef

trait Data[F, T, R] extends Serializable

trait Data0 extends AnyRef

trait Data1 extends Data0

trait DataT[F, T] extends Serializable

trait DataT0 extends AnyRef

trait DataT1 extends DataT0

trait DefaultCaseClassDefns extends ApplyUnapplyFacet with ProductFacet with PolymorphicEqualityFacet with CopyFacet with ToStringFacet

trait DefaultSymbolicLabelling[T] extends DepFn0 with Serializable

trait DepFn0 extends AnyRef

trait DepFn1[T] extends AnyRef

trait DepFn2[T, U] extends AnyRef

trait DerivationContext extends CaseClassMacros

type Everything[F <: Poly, K <: Poly, T] = Case[EverythingAux[F, K], ::[T, HNil]]

class EverythingAux[F, K] extends Poly

type Everywhere[F <: Poly, T] = Case[EverywhereAux[F], ::[T, HNil]]

class EverywhereAux[F] extends Poly

trait FieldOf[V] extends AnyRef

trait FieldPoly extends Poly1

trait Fin[N <: Succ[_]] extends AnyRef

case class FinSucc[N <: Succ[_], P <: Fin[N]]() extends Fin[Succ[N]] with Product with Serializable

case class FinZero[N <: Succ[_]]() extends Fin[N] with Product with Serializable

trait Generic[T] extends Serializable

trait Generic1[F[_], FR[_[_]]] extends Serializable

class Generic1Macros extends CaseClassMacros

class GenericMacros extends CaseClassMacros

sealed trait HList extends Product with Serializable

class HMap[R[_, _]] extends Poly1

class HMapBuilder[R[_, _]] extends AnyRef

sealed trait HNil extends HList

trait HasCoproductGeneric[T] extends Serializable

trait HasProductGeneric[T] extends Serializable

type Id[+T] = T

trait InferProduct[C <: Coproduct, K] extends AnyRef

final case class Inl[+H, +T <: Coproduct](head: H) extends :+:[H, T] with Product with Serializable

final case class Inr[+H, +T <: Coproduct](tail: T) extends :+:[H, T] with Product with Serializable

trait IsCCons1[L[_], FH[_[_]], FT[_[_]]] extends AnyRef

class IsCCons1Macros extends IsCons1Macros

trait IsCons1Macros extends CaseClassMacros

trait IsHCons1[L[_], FH[_[_]], FT[_[_]]] extends AnyRef

class IsHCons1Macros extends IsCons1Macros

trait IsTuple[T] extends Serializable

trait KeyConstraint[L <: HList, M <: HList] extends Serializable

trait LUBConstraint[L <: HList, B] extends Serializable

trait LabelledGeneric[T] extends Generic[T]

class LabelledMacros extends SingletonTypeUtils with CaseClassMacros

trait LabelledProductTypeClass[C[_]] extends Serializable

trait LabelledProductTypeClassCompanion[C[_]] extends Serializable

trait LabelledTypeClass[C[_]] extends LabelledProductTypeClass[C]

trait LabelledTypeClassCompanion[C[_]] extends LabelledProductTypeClassCompanion[C]

trait Lazy[+T] extends Serializable

class LazyMacros extends AnyRef

trait Lens[S, A] extends Dynamic with Serializable

trait LowPriorityMkPathOptic extends AnyRef

trait LowPriorityMkSelectDynamicOptic extends AnyRef

trait LowPrioritySegment extends AnyRef

trait LowPrioritySized extends AnyRef

trait LowPriorityTypeable extends AnyRef

trait LowPriorityWitnessWith extends AnyRef

trait Lub[-A, -B, Out] extends Serializable