deriving-compat-0.3.6: Backports of GHC deriving extensions

Copyright | (C) 2015-2017 Ryan Scott
License | BSD-style (see the file LICENSE)
Maintainer | Ryan Scott
Portability | Template Haskell
Safe Haskell | None
Language | Haskell2010

Data.Traversable.Deriving

Contents

- `Traversable`
- `deriveTraversable` limitations

Description

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.

Synopsis

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