Data.Reflection

Reifies arbitrary terms at the type level. Based on the Functional Pearl: Implicit Configurations paper by Oleg Kiselyov and Chung-chieh Shan.

http://okmij.org/ftp/Haskell/tr-15-04.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 Proxy t = Proxy, 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 examples/Monoid.hs).

In addition, a simpler API is offered for working with singleton values such as a system configuration, etc.

Reflection

class Reifies s a | s -> a where

Methods

reflect :: proxy s -> a

Recover a value inside a reify context, given a proxy for its reified type.

Instances

KnownNat n => Reifies (n :: Nat) Integer

Defined in Data.Reflection

Methods

reflect :: proxy n -> Integer

KnownSymbol n => Reifies (n :: Symbol) String

Defined in Data.Reflection

Methods

reflect :: proxy n -> String

Reifies Z Int

Defined in Data.Reflection

Methods

reflect :: proxy Z -> Int

Reifies n Int => Reifies (D n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (D n) -> Int

Reifies n Int => Reifies (PD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (PD n) -> Int

Reifies n Int => Reifies (SD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (SD n) -> Int

reify :: forall a r. a -> (forall (s :: *). Reifies s a => Proxy s -> r) -> r

Reify a value at the type level, to be recovered with reflect.

reifyNat :: forall r. Integer -> (forall (n :: Nat). KnownNat n => Proxy n -> r) -> r

This upgraded version of reify can be used to generate a KnownNat suitable for use with other APIs.

Attemping to pass a negative Integer as an argument will result in an Underflow exception.

Available only on GHC 7.8+

>>> import GHC.TypeLits

>>> reifyNat 4 natVal
4

>>> reifyNat 4 reflect
4

reifySymbol :: forall r. String -> (forall (n :: Symbol). KnownSymbol n => Proxy n -> r) -> r

This upgraded version of reify can be used to generate a KnownSymbol suitable for use with other APIs.

Available only on GHC 7.8+

>>> import GHC.TypeLits

>>> reifySymbol "hello" symbolVal
"hello"

>>> reifySymbol "hello" reflect
"hello"

reifyTypeable :: Typeable a => a -> (forall (s :: *). (Typeable s, Reifies s a) => Proxy s -> r) -> r

Reify a value at the type level in a Typeable-compatible fashion, to be recovered with reflect.

This can be necessary to work around the changes to Data.Typeable in GHC HEAD.

Given

class Given a where

This is a version of Reifies that allows for only a single value.

This is easier to work with than Reifies and permits extended defaulting, but it only offers a single reflected value of a given type at a time.

Methods

given :: a

Recover the value of a given type previously encoded with give.

give :: forall a r. a -> (Given a => r) -> r

Reify a value into an instance to be recovered with given.

You should only give a single value for each type. If multiple instances are in scope, then the behavior is implementation defined.

Template Haskell reflection

int :: Int -> TypeQ

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 Chung-Chieh 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).

nat :: Int -> TypeQ

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

data Z

0

Instances

Reifies Z Int

Defined in Data.Reflection

Methods

reflect :: proxy Z -> Int

data D (n :: *)

2n

Instances

Reifies n Int => Reifies (D n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (D n) -> Int

data SD (n :: *)

2n + 1

Instances

Reifies n Int => Reifies (SD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (SD n) -> Int

data PD (n :: *)

2n - 1

Instances

Reifies n Int => Reifies (PD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (PD n) -> Int

Reified Monoids

data ReifiedMonoid a

Constructors

ReifiedMonoid

Fields

• reifiedMappend :: a -> a -> a
• reifiedMempty :: a

newtype ReflectedMonoid a s

Constructors

ReflectedMonoid a

Instances

Reifies s (ReifiedMonoid a) => Monoid (ReflectedMonoid a s)

Defined in Data.Reflection

Methods

mempty :: ReflectedMonoid a s

mappend :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s

mconcat :: [ReflectedMonoid a s] -> ReflectedMonoid a s

Reifies s (ReifiedMonoid a) => Semigroup (ReflectedMonoid a s)

Defined in Data.Reflection

Methods

(<>) :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s

sconcat :: NonEmpty (ReflectedMonoid a s) -> ReflectedMonoid a s

stimes :: Integral b => b -> ReflectedMonoid a s -> ReflectedMonoid a s

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

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like foldMap where the Monoid instance can be manually specified.

foldMapBy mappend mempty ≡ foldMap

>>> foldMapBy (+) 0 length ["hello","world"]
10

foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like fold where the Monoid instance can be manually specified.

foldBy mappend mempty ≡ fold

>>> foldBy (++) [] ["hello","world"]
"helloworld"

Reified Applicatives

data ReifiedApplicative f

Constructors

ReifiedApplicative

Fields

• reifiedPure :: forall a. a -> f a
• reifiedAp :: forall a b. f (a -> b) -> f a -> f b

newtype ReflectedApplicative f s a

Constructors

ReflectedApplicative (f a)

Instances

Reifies s (ReifiedApplicative f) => Applicative (ReflectedApplicative f s)

Defined in Data.Reflection

Methods

pure :: a -> ReflectedApplicative f s a

(<*>) :: ReflectedApplicative f s (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b

liftA2 :: (a -> b -> c) -> ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s c

(*>) :: ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s b

(<*) :: ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s a

Reifies s (ReifiedApplicative f) => Functor (ReflectedApplicative f s)

Defined in Data.Reflection

Methods

fmap :: (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b

(<$) :: a -> ReflectedApplicative f s b -> ReflectedApplicative f s 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)

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)

Sequence a container using its Traversable instance using explicitly provided Applicative operations. This is like sequence where the Applicative instance can be manually specified.

Orphan instances

Num Exp

This permits the use of $(5) as an expression splice, which stands for Proxy :: Proxy $(5)

Methods

(+) :: Exp -> Exp -> Exp

(-) :: Exp -> Exp -> Exp

(*) :: Exp -> Exp -> Exp

negate :: Exp -> Exp

abs :: Exp -> Exp

signum :: Exp -> Exp

fromInteger :: Integer -> Exp

Num Type

This permits the use of $(5) as a type splice.

Methods

(+) :: Type -> Type -> Type

(-) :: Type -> Type -> Type

(*) :: Type -> Type -> Type

negate :: Type -> Type

abs :: Type -> Type

signum :: Type -> Type

fromInteger :: Integer -> Type

Num a => Num (Q a)

Methods

(+) :: Q a -> Q a -> Q a

(-) :: Q a -> Q a -> Q a

(*) :: Q a -> Q a -> Q a

negate :: Q a -> Q a

abs :: Q a -> Q a

signum :: Q a -> Q a

fromInteger :: Integer -> Q a

Fractional a => Fractional (Q a)

Methods

(/) :: Q a -> Q a -> Q a

recip :: Q a -> Q a

fromRational :: Rational -> Q a