Copyright  20092015 Edward Kmett, 2012 Elliott Hird, 2004 Oleg Kiselyov and Chungchieh Shan 

License  BSD3 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Stability  experimental 
Portability  nonportable 
Safe Haskell  Trustworthy 
Language  Haskell98 
Reifies arbitrary terms at the type level. Based on the Functional Pearl: Implicit Configurations paper by Oleg Kiselyov and Chungchieh Shan.
http://okmij.org/ftp/Haskell/tr1504.pdf
The approach from the paper was modified to work with Data.Proxy and to cheat by using knowledge of GHC's internal representations by Edward Kmett and Elliott Hird.
Usage comes down to two combinators, reify
and reflect
.
>>>
reify 6 (\p > reflect p + reflect p)
12
The argument passed along by reify is just a data
, so all of the information needed to reconstruct your value
has been moved to the type level. This enables it to be used when
constructing instances (see Proxy
t =
Proxyexamples/Monoid.hs
).
In addition, a simpler API is offered for working with singleton values such as a system configuration, etc.
 class Reifies s a  s > a where
 reflect :: proxy s > a
 reify :: forall a r. a > (forall s. Reifies s a => Proxy s > r) > r
 reifyNat :: forall r. Integer > (forall n. KnownNat n => Proxy n > r) > r
 reifySymbol :: forall r. String > (forall n. KnownSymbol n => Proxy n > r) > r
 reifyTypeable :: Typeable a => a > (forall s. (Typeable s, Reifies s a) => Proxy s > r) > r
 class Given a where
 given :: a
 give :: forall a r. a > (Given a => r) > r
 int :: Int > TypeQ
 nat :: Int > TypeQ
 data Z
 data D n
 data SD n
 data PD n
 data ReifiedMonoid a = ReifiedMonoid {
 reifiedMappend :: a > a > a
 reifiedMempty :: a
 newtype ReflectedMonoid a s = ReflectedMonoid a
 reifyMonoid :: (a > a > a) > a > (forall s. Reifies s (ReifiedMonoid a) => t > ReflectedMonoid a s) > t > a
 foldMapBy :: Foldable t => (r > r > r) > r > (a > r) > t a > r
 foldBy :: Foldable t => (a > a > a) > a > t a > a
 data ReifiedApplicative f = ReifiedApplicative {
 reifiedPure :: forall a. a > f a
 reifiedAp :: forall a b. f (a > b) > f a > f b
 newtype ReflectedApplicative f s a = ReflectedApplicative (f a)
 reifyApplicative :: (forall x. x > f x) > (forall x y. f (x > y) > f x > f y) > (forall s. Reifies s (ReifiedApplicative f) => t > ReflectedApplicative f s a) > t > f a
 traverseBy :: Traversable t => (forall x. x > f x) > (forall x y. f (x > y) > f x > f y) > (a > f b) > t a > f (t b)
 sequenceBy :: Traversable t => (forall x. x > f x) > (forall x y. f (x > y) > f x > f y) > t (f a) > f (t a)
Reflection
reify :: forall a r. a > (forall s. Reifies s a => Proxy s > r) > r Source
Reify a value at the type level, to be recovered with reflect
.
reifySymbol :: forall r. String > (forall n. KnownSymbol n => Proxy n > r) > r Source
This upgraded version of reify
can be used to generate a KnownSymbol
suitable for use with other APIs.
Available only on GHC 7.8+
>>>
reifySymbol "hello" symbolVal
"hello"
>>>
reifySymbol "hello" reflect
"hello"
reifyTypeable :: Typeable a => a > (forall s. (Typeable s, Reifies s a) => Proxy s > r) > r Source
Given
Template Haskell reflection
This can be used to generate a template haskell splice for a type level version of a given int
.
This does not use GHC TypeLits, instead it generates a numeric type by hand similar to the ones used in the "Functional Pearl: Implicit Configurations" paper by Oleg Kiselyov and ChungChieh Shan.
instance Num (Q Exp)
provided in this package allows writing $(3)
instead of $(int 3)
. Sometimes the two will produce the same
representation (if compiled without the DUSE_TYPE_LITS
preprocessor
directive).
This is a restricted version of int
that can only generate natural numbers. Attempting to generate
a negative number results in a compile time error. Also the resulting sequence will consist entirely of
Z, D, and SD constructors representing the number in zeroless binary.
Useful compile time naturals
Reified Monoids
data ReifiedMonoid a Source
ReifiedMonoid  

newtype ReflectedMonoid a s Source
Reifies k s (ReifiedMonoid a) => Monoid (ReflectedMonoid k a s) Source 
reifyMonoid :: (a > a > a) > a > (forall s. Reifies s (ReifiedMonoid a) => t > ReflectedMonoid a s) > t > a Source
Reified Applicatives
data ReifiedApplicative f Source
ReifiedApplicative  

newtype ReflectedApplicative f s a Source
ReflectedApplicative (f a) 
Reifies k s (ReifiedApplicative f) => Functor (ReflectedApplicative k * f s) Source  
Reifies k s (ReifiedApplicative f) => Applicative (ReflectedApplicative k * f s) Source 
reifyApplicative :: (forall x. x > f x) > (forall x y. f (x > y) > f x > f y) > (forall s. Reifies s (ReifiedApplicative f) => t > ReflectedApplicative f s a) > t > f a Source
traverseBy :: Traversable t => (forall x. x > f x) > (forall x y. f (x > y) > f x > f y) > (a > f b) > t a > f (t b) Source
Traverse a container using its Traversable
instance using
explicitly provided Applicative
operations. This is like traverse
where the Applicative
instance can be manually specified.
sequenceBy :: Traversable t => (forall x. x > f x) > (forall x y. f (x > y) > f x > f y) > t (f a) > f (t a) Source
Sequence a container using its Traversable
instance using
explicitly provided Applicative
operations. This is like sequence
where the Applicative
instance can be manually specified.