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

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+

>>> reifyNat 4 natVal
4

>>> reifyNat 4 reflect
4

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"

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.

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.

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.

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

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.

0

2 n

2 n + 1

2 n - 1

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

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"

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

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