Like Either, the :+: type defines a new type that can contain either H or T.
Non-empty HList
element type.
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.
Evidence that type T
has annotation A
, and provides an instance of the annotation.
Evidence that type T
has annotation A
, and provides an instance of the annotation.
If type T
has an annotation of type A
, then an implicit Annotation[A, T]
can be found, and its apply
method
provides an instance of the annotation.
Example:
case class First(i: Int) @First(3) trait Something val somethingFirst = Annotation[First, Something].apply() assert(somethingFirst == First(3))
Provides the annotations of type A
of the fields or constructors of case class-like or sum type T
.
Provides the annotations of type A
of the fields or constructors of case class-like or sum type T
.
If type T
is case class-like, this type class inspects its fields and provides their annotations of type A
. If
type T
is a sum type, its constructor types are looked for annotations.
Type Out
is an HList having the same number of elements as T
(number of fields of T
if T
is case class-like,
or number of constructors of T
if it is a sum type). It is made of None.type
(no annotation on corresponding
field or constructor) and Some[A]
(corresponding field or constructor is annotated).
Method apply
provides an HList of type Out
made of None
(corresponding field or constructor not annotated)
or Some(annotation)
(corresponding field or constructor has annotation annotation
).
Note that annotation types must be case class-like for this type class to take them into account.
Example:
case class First(s: String) case class CC(i: Int, @First("a") s: String) sealed trait Base @First("b") case class BaseI(i: Int) extends Base case class BaseS(s: String) extends Base val ccFirsts = Annotations[First, CC] val baseFirsts = Annotations[First, Base] // ccFirsts.Out is None.type :: Some[First] :: HNil // ccFirsts.apply() is // None :: Some(First("a")) :: HNil // baseFirsts.Out is Some[First] :: None.type :: HNil // baseFirsts.apply() is // Some(First("b")) :: None :: HNil
Type class witnessing that every element of L
is an element of M
.
The CNil type is used to terminate a 'list' of :+: alternatives.
The CNil type is used to terminate a 'list' of :+: alternatives.
Like the Nil constructor of List, it does not convey real information. This is achieved by not having any value for CNil.
This makes the type Int :+: CNil
equivalent to Int
, because the right (Inr
) alternative
of :+:
can not be constructed properly.
Wraps a cached implicit T
.
Wraps a cached implicit T
.
Looking for an implicit Cached[T]
first triggers a look for an implicit T
, caches the resulting
tree, and returns it immediately and in subsequent look ups for an implicit Cached[T]
. Thus,
subsequent look ups do not trigger looking for an implicit T
, only returning the instance kept in
cache.
Beware that if the contexts in which two subsequent look ups are different, so that looking for a
T
in each of them doesn't return the same result, this change would be ignored by caching. Looking
for a Cached[T]
in the first context would put the implicit T
of this context in cache, and then
looking for a Cached[T]
in the second context would return the former instance from the first
context. E.g.
trait TC[T] { def msg: String } object First { implicit val tc: TC[Int] = new TC[Int] { val msg = "first" } def print() = println(implicitly[TC[Int]].msg) def printCached() = println(cached[TC[Int]].msg) } object Second { implicit val tc: TC[Int] = new TC[Int] { val msg = "second" } def print() = println(implicitly[TC[Int]].msg) def printCached() = println(cached[TC[Int]].msg) } First.print() Second.print() First.printCached() Second.printCached()
would print "first" then "second" (non cached TC[Int]
instances), then "first" twice (first instance, returned
the second time too through the cache).
Encodes a coproduct type, such as a sealed family of case classes.
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>
Type class representing one-level generic queries.
Type class representing one-level generic transformations.
Provides default values of case class-like types.
Provides default values of case class-like types.
The Out
type parameter is an HList type whose length is the number of fields of T
. Its elements correspond
to the fields of T
, in their original order. It is made of None.type
(no default value for this field) and
Some[...]
(default value available for this field, with ...
the type of the field). Note that None.type
and
Some[...]
are more precise than simply Option[...]
, so that the availability of default values can be used
in type level calculations.
The apply
method returns an HList of type Out
, with None
elements corresponding to no default value available,
and Some(defaultValue)
to default value available for the corresponding fields.
Use like
case class CC(i: Int, s: String = "b") val default = Default[CC] // default.Out is None.type :: Some[String] :: HNil // default() returns // None :: Some("b") :: HNil, // typed as default.Out
Dependent nullary function type.
Dependent unary function type.
Dependent binary function type.
The SYB everything combinator
The SYB everywhere combinator
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.
Polymorphic function that allows modifications on record fields while preserving the original key types.
Base trait for type level finite numbers, i.e.
Base trait for type level finite numbers, i.e. numbers less than some bound N
Encoding of successor.
Encoding of zero.
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. }}}
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.
HList
ADT base trait.
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
.
HMap
s extend Poly
and hence are also polymorphic function values with type-specific
cases corresponding to the map's type-level key/value associations.
Empty HList
element type.
H :+: T
can either be H
or T
.
H :+: T
can either be H
or T
.
In this case it is H
.
H :+: T
can either be H
or T
.
H :+: T
can either be H
or T
.
In this case it is T
.
Type class witnessing that all elements of L
have distinct types
Type class witnessing that all elements of L
have distinct types
Type class witnessing that every element of L
is of the form FieldType[K, V]
where K
is an element of M
.
Type class witnessing that every element of L
is a subtype of B
.
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)
the type which this instance can convert to and from a labelled generic representation
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.
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.
Wraps a lazily computed value.
Wraps a lazily computed value. Also circumvents cycles during implicit search, or wrong implicit divergences as illustrated below, and holds the corresponding implicit value lazily.
The following implicit search sometimes fails to compile, because of a wrongly reported implicit divergence,
case class ListCC(list: List[CC]) case class CC(i: Int, s: String) trait TC[T] object TC { implicit def intTC: TC[Int] = ??? implicit def stringTC: TC[String] = ??? implicit def listTC[T](implicit underlying: TC[T]): TC[List[T]] = ??? implicit def genericTC[F, G](implicit gen: Generic.Aux[F, G], underlying: TC[G] ): TC[F] = ??? implicit def hnilTC: TC[HNil] = ??? implicit def hconsTC[H, T <: HList](implicit headTC: TC[H], tailTC: TC[T] ): TC[H :: T] = ??? } implicitly[TC[CC]] // fails with: diverging implicit expansion for type TC[CC]
This wrongly reported implicit divergence can be circumvented by wrapping some of the implicit values in
Lazy
,
case class ListCC(list: List[CC]) case class CC(i: Int, s: String) trait TC[T] object TC { implicit def listTC[T](implicit underlying: TC[T]): TC[List[T]] = ??? implicit def genericTC[F, G](implicit gen: Generic.Aux[F, G], underlying: Lazy[TC[G]] // wrapped in Lazy ): TC[F] = ??? implicit def hnilTC: TC[HNil] = ??? implicit def hconsTC[H, T <: HList](implicit headTC: Lazy[TC[H]], // wrapped in Lazy tailTC: TC[T] ): TC[H :: T] = ??? } implicitly[TC[CC]]
When looking for an implicit Lazy[TC[T]]
, the Lazy.mkLazy
macro will itself trigger the implicit search
for a TC[T]
. If this search itself triggers searches for types wrapped in Lazy
, these will be done
only once, their result put in a lazy val
, and a reference to this lazy val
will be returned as the corresponding
value. It will then wrap all the resulting values together, and return a reference to the first one.
E.g. with the above example definitions, when looking up for an implicit TC[CC]
, the returned tree roughly looks
like
TC.genericTC( Generic[CC], // actually, the tree returned by Generic.materialize, not written here for the sake of brevity Lazy { lazy val impl1: TC[List[CC] :: HNil] = TC.hconsTC( Lazy(impl2), TC.hnilTC ) lazy val impl2: TC[List[CC]] = TC.listTC(TC.genericTC( Generic[CC], // actually, the tree returned by Generic.materialize Lazy(impl1) // cycles to the initial TC[List[CC] :: HNil] )) impl1 } )
Evidence that no implicit instance of the same type as the one being currently searched is available elsewhere.
Evidence that no implicit instance of the same type as the one being currently searched is available elsewhere.
Added to an implicit def like
implicit def genericThing[F, G] (implicit ev: LowPriority, gen: Generic.Aux[F, G], underlying: Thing[G] ): Thing[F] = ???
it prevents genericThing
to provide an instance of Thing[F]
if an implicit one is already
available elsewhere. This effectively gives genericThing
a lower priority than the already
existing implicits - without having to deal with cumbersome priority scoping.
Type class witnessing the least upper bound of a pair of types and providing conversions from each to their common supertype.
Base trait for type level natural numbers.
Trait supporting mapping dynamic argument lists of Ints to HList of Nat arguments.
Trait supporting mapping dynamic argument lists of Ints to HList of Nat arguments.
Mixing in this trait enables method applications of the form,
lhs.method(1, 2, 3)
to be rewritten as,
lhs.methodProduct(_1 :: _2 :: _3)
ie. the arguments are rewritten as HList elements of Nat and the application is rewritten to an application of an implementing method (identified by the "Product" suffix) which accepts a single HList of Int argument.
Type class witnessing that L
doesn't contain elements of type U
Type class witnessing that L
doesn't contain elements of type U
Base trait for polymorphic values.
Trait simplifying the creation of polymorphic values.
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.
A type class abstracting over the product
operation of type classes over
types of kind *
, as well as deriving instances using an isomorphism.
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.
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.
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,
Array
s, String
s etc.
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.
Wraps an eagerly computed value.
Wraps an eagerly computed value. Prevents wrongly reported implicit divergence, like Lazy
does, but,
unlike it, does not circumvent implicit cycles.
Creation of Lazy
instances usually triggers the creation of an anonymous class, to compute the wrapped
value (e.g. with the by-name argument of Lazy.apply
). Strict
avoids that, which can lead to less
overhead during compilation.
Encoding of successor.
Extractor for use of Typeable
in pattern matching.
Extractor for use of Typeable
in pattern matching.
Thanks to Stacy Curl for the idea.
A type class additionally abstracting over the coproduct
operation of type
classes over types of kind *
.
Type class supporting type safe cast.
Type class witnessing that every element of L
has TC
as its outer type constructor.
Type class witnessing that type PP
is equal to FF[A]
for some higher kinded type FF[_]
and type(s) A
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
Type class witnessing that type PP
is equal to FF[A, B]
for some higher kinded type FF[_, _]
and type(s) A, B
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
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
.
Type class witnessing that every element of L
is of the form FieldType[K, V]
where V
is an element of M
.
Provides the widen type of a singleton type.
Provides the widen type of a singleton type.
Type member Out
of an implicitly available Witness[T]
instance is the widen type
of T
, and the apply
method explicitly converts a T
to an Out
.
E.g. if T
is
.TWitness.
2
is ,
OutInt
.
It somehow complements Witness
, providing the corresponding non-witnessed standard type, if any.
Example of use,
{{
val w = Widen[Witness.2
.T]
// w.Out is Int
// w(2) is typed as Int
}}
Provides the value corresponding to a singleton type.
Provides the value corresponding to a singleton type.
See SIP-23 for a related proposed language change.
Generic Zipper for any type with a representation via Generic
.
Encoding of zero.
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]
.
This object was generated by sbt-buildinfo.
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.
Empty HList
value.
Type level encoding of the natural numbers.
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.
Provides instances of Typeable
.
Provides instances of Typeable
. Also provides an implicit conversion which enhances arbitrary values with a
cast[T]
method.
'Fin'
Nat
literals
Optic
definitions
Poly
definitions
Higher ranked function which converts products to HLists
.
Record operations on HList
's with field-like elements.
An enhanced alternative to Predef.implicitly
.
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
Higher ranked function which converts HLists
to tuples.