Hackage :: [Package]

simplistic-generics: Generic programming without too many type classes

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

This library provides a representation build on top of GHC.Generics, which can be used to describe generic operations on a single function, instead of having each case defined in an instance of a type class.

[Skip to Readme]

Properties

Versions 0.1.0.0, 0.1.0.0, 2.0.0
Change log None available
Dependencies base (>=4.12 && <5), comonad, kind-apply [details]
License BSD-3-Clause
Author Alejandro Serrano
Maintainer trupill@gmail.com
Category Data
Source repo head: git clone https://gitlab.com/trupill/simplistic-generics
Uploaded by AlejandroSerrano at 2019-05-16T14:03:39Z

Modules

[Index] [Quick Jump]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Readme for simplistic-generics-0.1.0.0

[back to package description]

simplistic-generics: generic programming without too many type classes

This library provides a way to do data type-generic programming in GHC, re-using almost all the machinery from GHC.Generics, but without the need to define a different generic type class for each new operation.

Say that you want to define an operation op in a generic fashion. The docs of GHC.Generics tell you that you need to create a new type class whose argument is the set of pattern functors that may generate the data type. Then by means of a default declaration you bridge the gap between both versions. Furthermore, in almost every case the instances of this class follow the same pattern:

class GOp (f :: * -> *) where
  gop :: ...
instance GOp U1 where ...
instance (GOp f, GOp g) => GOp (f :+: g) where ...
instance (GOp f, GOp g) => GOp (f :*: g) where ...
instance (GOp f) => GOp (M1 i p f) where ...
instance Op t => GOp (K1 r t) where ...

class Op a where
  op :: ...
  default op :: (Generic a, GOp (Rep a)) => ...
  op = ... gop ...

When using simplistic-generics you do not introduce such a type class; you just write all the cases of the generic function in one go! The only thing you need to remember is that you have to pattern match on values of the type SRep w f, where f is the pattern functor from GHC.Generics. The definition of the previous operation looks then:

gop :: ... SRep w f ...
gop ... S_U1       ... = ...
gop ... (S_L1 x)   ... = ...
gop ... (S_R1 x)   ... = ...
gop ... (x :**: y) ... = ...
gop ... (S_M1 x)   ... = ...
gop ... (S_K1 x)   ... = ...

There is only one missing link here. In the definition of GOp using type classes we tied the knot by asking the K1 instance to satisfy Op recursively. In the case of SRep we have a special OnLeaves combinator which requires a constraint from each K1 node. The signature for gop should read then:

gop :: OnLeaves Op f => ... SRep w f ...

The final touch is that instead of using from and to to convert back and forth generic representations, you use fromS and toS to get a SRep w f.

For real examples, check the Derive folder in the repo.

Inspiration

This library is inspired by several previous work: