Copyright | (C) 2015-2017 Ryan Scott |
---|---|

License | BSD-style (see the file LICENSE) |

Maintainer | Ryan Scott |

Portability | Template Haskell |

Safe Haskell | None |

Language | Haskell2010 |

Exports functions to mechanically derive `Traversable`

instances in a way that mimics
how the `-XDeriveTraversable`

extension works since GHC 8.0.

Derived `Traversable`

instances from this module do not generate
superfluous `pure`

expressions in its implementation of `traverse`

. One can
verify this by compiling a module that uses `deriveTraversable`

with the
`-ddump-splices`

GHC flag.

These changes make it possible to derive `Traversable`

instances for data types with
unlifted argument types, e.g.,

data IntHash a = IntHash Int# a deriving instance Traversable IntHash -- On GHC 8.0 on later $(deriveTraversable ''IntHash) -- On GHC 7.10 and earlier

For more info on these changes, see this GHC wiki page.

- deriveTraversable :: Name -> Q [Dec]
- makeTraverse :: Name -> Q Exp
- makeSequenceA :: Name -> Q Exp
- makeMapM :: Name -> Q Exp
- makeSequence :: Name -> Q Exp

`Traversable`

deriveTraversable :: Name -> Q [Dec] Source #

Generates a `Traversable`

instance declaration for the given data type or data
family instance.

makeTraverse :: Name -> Q Exp Source #

Generates a lambda expression which behaves like `traverse`

(without requiring a
`Traversable`

instance).

makeSequenceA :: Name -> Q Exp Source #

Generates a lambda expression which behaves like `sequenceA`

(without requiring a
`Traversable`

instance).

makeMapM :: Name -> Q Exp Source #

Generates a lambda expression which behaves like `mapM`

(without requiring a
`Traversable`

instance).

makeSequence :: Name -> Q Exp Source #

Generates a lambda expression which behaves like `sequence`

(without requiring a
`Traversable`

instance).

`deriveTraversable`

limitations

Be aware of the following potential gotchas:

- If you are using the
`-XGADTs`

or`-XExistentialQuantification`

extensions, an existential constraint cannot mention the last type variable. For example,`data Illegal a = forall a. Show a => Illegal a`

cannot have a derived`Traversable`

instance. - Type variables of kind
`* -> *`

are assumed to have`Traversable`

constraints. If this is not desirable, use`makeTraverse`

.