one-liner-instances: Generics-based implementations for common typeclasses

[ bsd3, library, web ] [ Propose Tags ]

Provides generics-based implementations for common typeclasses using Generics.

Please see the README on Github at https://github.com/mstksg/one-liner-instances#readme


[Skip to Readme]
Versions 0.1.0.0, 0.1.1.0, 0.1.2.0, 0.1.2.1 (info)
Change log CHANGELOG.md
Dependencies base (>=4.7 && <5), one-liner (>=0.9), random [details]
License BSD-3-Clause
Copyright (c) Justin Le 2018
Author Justin Le
Maintainer justin@jle.im
Category Web
Home page https://github.com/mstksg/one-liner-instances#readme
Bug tracker https://github.com/mstksg/one-liner-instances/issues
Source repo head: git clone https://github.com/mstksg/one-liner-instances
Uploaded by jle at Sat Apr 21 07:47:05 UTC 2018
Distributions LTSHaskell:0.1.2.1, NixOS:0.1.1.0, Stackage:0.1.2.1, openSUSE:0.1.1.0
Downloads 108 total (47 in the last 30 days)
Rating (no votes yet) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2018-04-21 [all 1 reports]
Hackage Matrix CI

Modules

[Index]

Downloads

Maintainer's Corner

For package maintainers and hackage trustees


Readme for one-liner-instances-0.1.2.1

[back to package description]

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.

So, gPlus (generic addition) will work for:

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:

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.

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.