deriving-compat-0.6.5: Backports of GHC deriving extensions

# deriving-compat-0.6.5: Backports of GHC deriving extensions

`deriving-compat` provides Template Haskell functions that mimic `deriving` extensions that were introduced or modified in recent versions of GHC. Currently, the following typeclasses/extensions are covered:

- Deriving `Bounded`
- Deriving `Enum`
- Deriving `Ix`
- Deriving `Eq`
- Deriving `Ord`
- Deriving `Read`
- Deriving `Show`

-     DeriveFoldable

-     DeriveFunctor

-     DeriveTraversable

- `GeneralizedNewtypeDeriving` (with GHC 8.2 or later)
- `DerivingVia` (with GHC 8.2 or later)

See the Data.Deriving module for a full list of backported changes.

In addition, `deriving-compat` also provides some additional `deriving` functionality that has not yet been merged into upstream GHC. Aside from the GHC `deriving` extensions mentioned above, `deriving-compat` also permits deriving instances of classes in the `Data.Functor.Classes` module, covering the `Eq1`, `Eq2`, `Ord1`, `Ord2`, `Read1`, `Read2`, `Show1`, and `Show2` classes. This extra functionality is outside of the main scope of `deriving-compat`, as it does not backport extensions that exist in today's GHC. Nevertheless, the underlying Template Haskell machinery needed to derive `Eq` and friends extends very naturally to `Eq1` and friends, so this extra functionality is included in `deriving-compat` as a convenience.

Note that some recent GHC typeclasses/extensions are not covered by this package:

-     DeriveDataTypeable

- `DeriveGeneric`, which was introducted in GHC 7.2 for deriving `Generic` instances, and modified in GHC 7.6 to allow derivation of `Generic1` instances. Use `Generics.Deriving.TH` from `generic-deriving` to derive `Generic(1)` using Template Haskell.
- `DeriveLift`, which was introduced in GHC 8.0 for deriving `Lift` instances. Use `Language.Haskell.TH.Lift` from `th-lift` to derive `Lift` using Template Haskell.
- The `Bifunctor` typeclass, which was introduced in GHC 7.10, as well as the `Bifoldable` and `Bitraversable` typeclasses, which were introduced in GHC 8.2. Use `Data.Bifunctor.TH` from `bifunctors` to derive these typeclasses using Template Haskell.

Modules

deriving-compat-0.6.5

- Data
  Submodules
  - Bounded
    Submodules
    - Data.Bounded.Deriving
      Submodules
      - Data.Bounded.Deriving.Internal
  - Data.Deriving
    Submodules
    - Data.Deriving.Internal
    - Data.Deriving.Via
      Submodules
      - Data.Deriving.Via.Internal
  - Enum
    Submodules
    - Data.Enum.Deriving
      Submodules
      - Data.Enum.Deriving.Internal
  - Eq
    Submodules
    - Data.Eq.Deriving
      Submodules
      - Data.Eq.Deriving.Internal
  - Foldable
    Submodules
    - Data.Foldable.Deriving
  - Functor
    Submodules
    - Data.Functor.Deriving
      Submodules
      - Data.Functor.Deriving.Internal
  - Ix
    Submodules
    - Data.Ix.Deriving
      Submodules
      - Data.Ix.Deriving.Internal
  - Ord
    Submodules
    - Data.Ord.Deriving
      Submodules
      - Data.Ord.Deriving.Internal
  - Traversable
    Submodules
    - Data.Traversable.Deriving
- Text
  Submodules
  - Read
    Submodules
    - Text.Read.Deriving
      Submodules
      - Text.Read.Deriving.Internal
  - Show
    Submodules
    - Text.Show.Deriving
      Submodules
      - Text.Show.Deriving.Internal