Haskell polymorphic function to convert between algebraic data types

Question

I have two haskell functions, which convert between two algebraic data types.

data Ab = A | B
data Cd = C | D

fromAb :: Ab -> Cd
fromAb A = C
fromAb B = D

toAb :: Cd -> Ab
toAb C = A
toAb D = B

But I would like to make a polymorph function, that takes both algebraic data types and converts between them.

foo A = C
foo B = D
foo C = A
foo D = B

But Haskell deduces from "foo A = C" that the function is

foo :: Ab -> Cd

I tried to make the data types instances of a class to make foo polymorph but it didn't work.

class Abcd a
instance Abcd Ab
instance Abcd Cd

foo :: Abcd a => a -> Ab

Any Ideas?

Answer 1

This is very natural with TypeFamilies. You define a type-level function

type family Converted a
type instance Converted Ab = Cd
type instance Converted Cd = Ab

Then your signature becomes

foo :: a -> Converted a

If you just were fiddling with types you'd be done, but since you want to have different behavior on the value level (returning an A from a C and so on) we actually need to spread our cases across instances of a new type class:

class Convertable a where
    foo :: a -> Converted a

instance Convertable Ab where
    foo A = C
    foo B = D

instance Convertable Cd where
    foo C = A
    foo D = B

(live demo)

Finally, you might consider making Converted a closed type synonym family if using recent GHC, or make it "associated" by moving the instances inside the Convertable instance declarations.

Answer 2

Well, the signature in your last code fragment there is still wrong. It wouldn't be foo :: Abcd a => a -> Ab, since if a ~ Ab then the function should be returning a Cd, not an Ab.

There are a few different ways of doing what you want. First, recognize that what you're trying to do is express a common set of behavior based not on a type, but on a relationship between two types. This is basically the purpose of a multi-parameter typeclass (which is probably the simplest way to accomplish this).

{-# LANGUAGE MultiParamTypeClasses #-}
data Ab = A | B
data Cd = C | D

fromAb :: Ab -> Cd
fromAb A = C
fromAb B = D

toAb :: Cd -> Ab
toAb C = A
toAb D = B

class Iso a b where
  to :: a -> b

instance Iso Ab Cd where
  to = fromAb

instance Iso Cd Ab where
  to = toAb

EDIT: Note that my answer is completely equivalent to jberryman's, which uses type families. This is what I mean by "a few ways of doing what you want."