one-liner-instances
===================

This package uses machinery from *[one-liner][]* in order to provide default
implementations for methods from `Num`, `Fractional`, `Floating`, `Semigroup`,
`Monoid`, `Bounded`, `Eq`, `Ord`, and `Random`.  These will work for any types
(deriving `Generic`) whose fields are all instances of that typeclass.

For `Num`, `Fractional`, `Floating`, `Semigroup`, and `Monoid`, the types also
must have only a single constructor.  `Random` methods offer variants with
single constructors (for performance) and with multiple constructors.

[one-liner]: https://hackage.haskell.org/package/one-liner

So, `gPlus` (generic addition) will work for:

```haskell
data Tup1 a b = Tup1 a b            -- requires Num a, Num b
data Tup2 a   = Tup2 Int a          -- requires Num a, Num b
data Tup3     = Tup3 Int Double
data Tup4 a b = Tup4 Int Double     -- no constraint on a or b
```

But not on:

```haskell
data Tup5 a   = Tup2 String a       -- String is not an instance of Num
```

These are implemented by applying the operation to every field.

Newtype wrappers
----------------

Similar to `WrappedMonoid` and `WarppedMonad` from *base*, some convenient
newtype wrappers are provided that will give free instances of `Num`, etc. for
appropriate types:

If `a` is a data type (deriving `Generic`) with a single constructor whose
fields all have instances of `Num`, then `GNum a` has a `Num` instance (and
same for `Fractional`, `Floating`, etc.).

If `a` is a data type (deriving `Generic`) with a single constructor whose
fields all have instances of `Semigroup`, then `GMonoid a` has a `Semigroup`
instance (and same for `Monoid`).

If `a` is a data type (deriving `Generic`) whose fields all have instances of
`Bounded`, then `GBounded a` has a `Bounded` instance.

If `a` is a data type (deriving `Generic`) whose fields all have instances of
`Eq`, then `GOrd a` has a `Eq` instance (and same for
`Ord`).

Comparisons
-----------

This package provides very similar functionality to *[generic-deriving][]*.

[generic-deriving]: http://hackage.haskell.org/package/generic-deriving

There are a few major design differences between *generic-deriving* and
*one-liner*, the package that this one is built on.

*generic-deriving* creates a *separate* "deriving" typeclass for every
typeclass one wants to generalize.  So, there is a separate `GMonoid`
typeclass, a separate `GEnum` typeclass, etc.

*one-liner* instead creates a single typeclass (`ADTRecord` and `Constraints`)
to unify all generalizable typeclasses.  Both the generic `Monoid` and generic
`Num` instances are built upon the same `Constraints` typeclass.  From a
usability standpoint, *one-liner* allows one to easily create generic versions
of their own, custom typeclasses -- something that *generic-deriving* does not
help with.

*one-liner-instances*, however, is simply a package using the *one-liner*
engine to provide generic instances for common classes where it is possible.

The main difference in practical usability between *one-liner-instances* and
*generic-deriving* themselves are few, but are mainly:

*   *one-liner-instances* has generic implementations for
    `Num`/`Fractional`/`Floating`, and *generic-deriving* doesn't.  This is a
    superficial difference, however, since nothing fundamental is preventing
    *generic-deriving* from adding them in the future.
*   *one-liner-instances* provides newtype wrappers that can automatically
    imbue appropriate types with instances, which can be used with the upcoming
    [DerivingVia][] syntax to automatically derive instances, or just used on
    their own for convenience purposes.

    *generic-deriving* does not aim to do this at this moment.
*   Integrates with the rest of the *one-liner* ecosystem, if one is already
    using it to provide constraints for custom typeclasses.

[DerivingVia]: https://twitter.com/Iceland_jack/status/959923603096719360