Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/mstksg/one-liner-instances

Default implementations for common typeclasses using one-liner
https://github.com/mstksg/one-liner-instances

Last synced: about 2 months ago
JSON representation

Default implementations for common typeclasses using one-liner

Awesome Lists containing this project

README 

        
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