Automatically deriving Generic for every algebraic data type

newer
Re: Automatically deriving Generic...

older
Specializing expressions beyond...

Wolfgang Jeltsch

4 Feb 2016 4 Feb '16

7:19 a.m.

Hi, if you do generic programming these days, you can use DeriveAnyClass to write code like the following (where Serializable is a class with a generic default implementation):

...

data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving (Generic, Serializable)

It would be great, if you could just write the following instead:

...

data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving Serializable

This would correspond exactly to what you do when using standard Haskell deriving. It could be made possible by letting the compiler instantiate the Generic class automatically every time an algebraic data type is declared. A potential downside of this would be that programmers would not be able to define non-standard instances of Generics, but I actually cannot see that this is very useful anyhow. Any comments? All the best, Wolfgang

Show replies by date

Wolfgang Jeltsch

4 Feb 4 Feb

7:28 a.m.

Am Donnerstag, den 04.02.2016, 14:19 +0200 schrieb Wolfgang Jeltsch:

...

Hi,

if you do generic programming these days, you can use DeriveAnyClass to write code like the following (where Serializable is a class with a generic default implementation):

...
data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving (Generic, Serializable)

It would be great, if you could just write the following instead:

...
data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving Serializable

This would correspond exactly to what you do when using standard Haskell deriving. It could be made possible by letting the compiler instantiate the Generic class automatically every time an algebraic data type is declared. A potential downside of this would be that programmers would not be able to define non-standard instances of Generics, but I actually cannot see that this is very useful anyhow.

I want to add that this would probably allow us to implement all the other deriving mechanisms (for standard classes, for Functor, etc.) entirely in libraries, using generic programming, without forcing users to change their code by adding deriving of Generic. Maybe a future standard Haskell would not even have deriving rules hardwired into the language anymore (which always felt somehow wrong to me). Wouldn’t this be great? ;-) All the best, Wolfgang

Oleg Grenrus

8:17 a.m.

Hi, sometimes I want to use Generic derivation, but don’t want expose the Generic instance outside the module. The reason, is that for some types I want to export only smart constructors / modifier lenses; yet the structure is probably simple enough to benefit from `Generic`. If it will be possible to restrict export of the Generic instance, then I don’t see problem of auto-deriving it for everything possible though. - Oleg

...

On 04 Feb 2016, at 14:28, Wolfgang Jeltsch wrote:

Am Donnerstag, den 04.02.2016, 14:19 +0200 schrieb Wolfgang Jeltsch:

...
Hi,

if you do generic programming these days, you can use DeriveAnyClass to write code like the following (where Serializable is a class with a generic default implementation):

...
data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving (Generic, Serializable)

It would be great, if you could just write the following instead:

...
data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving Serializable

This would correspond exactly to what you do when using standard Haskell deriving. It could be made possible by letting the compiler instantiate the Generic class automatically every time an algebraic data type is declared. A potential downside of this would be that programmers would not be able to define non-standard instances of Generics, but I actually cannot see that this is very useful anyhow.

I want to add that this would probably allow us to implement all the other deriving mechanisms (for standard classes, for Functor, etc.) entirely in libraries, using generic programming, without forcing users to change their code by adding deriving of Generic. Maybe a future standard Haskell would not even have deriving rules hardwired into the language anymore (which always felt somehow wrong to me). Wouldn’t this be great? ;-)

All the best, Wolfgang

_______________________________________________ ghc-devs mailing list ghc-devs@haskell.org mailto:ghc-devs@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs

Roman Cheplyaka

9:21 a.m.

On 02/04/2016 02:19 PM, Wolfgang Jeltsch wrote:

...

Hi,

if you do generic programming these days, you can use DeriveAnyClass to write code like the following (where Serializable is a class with a generic default implementation):

...
data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving (Generic, Serializable)

It would be great, if you could just write the following instead:

...
data Tree a = Leaf | Branch (Tree a) a (Tree a) deriving Serializable

This would correspond exactly to what you do when using standard Haskell deriving. It could be made possible by letting the compiler instantiate the Generic class automatically every time an algebraic data type is declared. A potential downside of this would be that programmers would not be able to define non-standard instances of Generics, but I actually cannot see that this is very useful anyhow.

Any comments?

GHC.Generics already have an unfair advantage over the alternative (and arguably, superior) libraries, such as generics-sop. I wouldn't want to give it even more special treatment than it receives right now. Roman

3393

Age (days ago)

3393

Last active (days ago)

List overview

Download

3 comments

3 participants

participants (3)

Oleg Grenrus
Roman Cheplyaka
Wolfgang Jeltsch