How to write a generic function for any data constructor?

Question

Suppose I have these definitions of a data in Haskell.

data Point a = Point a a
data Piece a = One a | Two a

and I want to have one function like

place :: Num a => Piece (Point a) -> Point a
place (Piece x) = x

how do I do this since haskell doesn't allow functions of that particular form.

Solution

The problem was my data definition (many years of empirical programming is interfering here...). I wanted my Piece data to effectively be 2 different things, a Piece and also a kind of piece, I tried to achieve this with inheritance which was just a bad approach. Separating data in the following way solved the problem.

data PieceKind = One | Two | ... | n
data Piece a b = Piece a PieceKind

This way my Piece effectively has two attributes "a" (in my case this is a position of a piece) and also PieceKind, this way I was able to write the place function without having to repeat it for every kind of piece in the following way:

place :: Num a => Piece (Point a) PieceKind -> Point a
place (Piece x _) = x

In addition I was also able to write functions for a particular kind of a Piece:

place :: Num a => Piece (Point a) PieceKind -> Point a
place (Piece _ One) = ...

and this is what I really wanted.

Is your intent to have it work like place (One x) = x; place (Two x) = x ? — Justin L.
– Justin L., Commented Feb 4, 2017 at 9:35
Yes, instead of having one function for every constructor I want to have just one function for all of them. — Dovydas Rupšys
– Dovydas Rupšys, Commented Feb 4, 2017 at 9:47

chi · Accepted Answer · 2017-02-04 10:20:55Z

2

Use a record for the common fields

data Piece a = One { place :: a } | Two { place :: a }
-- place automatically defined

Or factorize the common data

data Piece a = Piece Bool a

place :: Piece a -> a
place (Piece _ x) = x

-- optionally:
pattern One x = Piece False x
pattern Two x = Piece True  x

In the general case, instead of Bool you have to use a custom sum type to express the rest of the factorization. E.g.

data T a = A Int a | B Bool a

becomes

data T a = T (Either Int Bool) a
-- optionally:
pattern A n x = T (Left n)  x
pattern B b x = T (Right b) x

Template Haskell could also solve this, but it is overkill, IMO.

edited Feb 4, 2017 at 10:20

answered Feb 4, 2017 at 10:05

chi

117k4 gold badges143 silver badges230 bronze badges

Sign up to request clarification or add additional context in comments.

8 Comments

Dovydas Rupšys Over a year ago

Still not entirely what I was expecting, your suggestion is ok if you have a few constructors but what if you have 10 and they all have a shared function, then with your solution I would have to repeat { place :: a } 10 times. There must be a better way.

ThreeFx Over a year ago

@DovydasRupšys Not if you factor your data correctly, as suggested below.

chi Over a year ago

@DovydasRupšys I don't think there's a much easier way. You could autogenerate the function you want with Template Haskell, which can generate code for you as in a macro system, but setting it up for this would require some care. If you have a very large amount of types/constructors, it could be worth it, but otherwise it requires too much effort.

Dovydas Rupšys Over a year ago

I'm failing to see how the above factorization applies, I don't even see where the factorization is happening. Is the meaning of factorization the same in functional languages as it is in empirical?

Dovydas Rupšys Over a year ago

Wait, nvm I think I get it.

|

Collectives™ on Stack Overflow

How to write a generic function for any data constructor?

1 Answer 1

8 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

8 Comments

Your Answer

Sign up or log in

Post as a guest

Related