Abstract factories in Haskell

Question

I was wondering how to implement the Abstract Factory design pattern, common in object-oriented languages, in a functional language. In particular, I am interested in an Haskell implementation.

I tried to implement the pattern using type classes:

class Product p where
  toString :: p -> String

class Factory f where
  createProduct :: Product p => f -> p

data FirstProduct = FirstProduct
data FirstFactory = FirstFactory

instance Product FirstProduct where
  toString _ = "first product"

instance Factory FirstFactory where
  createProduct _ = FirstProduct

When compiling this code, the following error is returned instead:

Could not deduce (p ~ FirstProduct)
from the context (Product p)
  bound by the type signature for
             createProduct :: Product p => FirstFactory -> p
  at test.hs:14:3-15
  ‘p’ is a rigid type variable bound by
      the type signature for
        createProduct :: Product p => FirstFactory -> p
      at test.hs:14:3
Relevant bindings include
  createProduct :: FirstFactory -> p (bound at test.hs:14:3)
In the expression: FirstProduct
In an equation for ‘createProduct’: createProduct _ = FirstProduct

It looks like the compiler is not happy with the implementation of createProduct, and in particular with its return value. I though that returning any instance of the Product type class could do the trick, but it obviously doesn't.

I would like to know if something similar to an Abstract Factory can be implemented in Haskell or if my approach is completely wrong. Are there any other "patterns" I could use to achieve a similar result?

Edit

According to the suggestions and explanations of leftaroundabout, I came up with a different solution that fulfills my needs without misusing type classes. The solution could be probably be improved, but at the moment this is the best I was able to achieve.

The library would have to define something similar to the following:

data ProductSystem p = ProductSystem {create :: p, toString :: p -> String }

productUser :: ProductSystem p -> String
productUser system = toString system $ create system

Some users of the library could provide "implementations" of the ProductSystem for their concrete needs:

data FirstProduct = FirstProduct

firstSystem :: ProductSystem FirstProduct
firstSystem = ProductSystem create toString
  where 
    create = FirstProduct
    toString p = "first"

data SecondProduct = SecondProduct

secondSystem :: ProductSystem SecondProduct
secondSystem = ProductSystem create toString
  where
    create = SecondProduct
    toString p = "second"

Somewhere else, the two pieces could be unified to execute the wanted behavior:

productUser firstSystem
productUser secondSystem

Answer 1

As I already commented, the whole idea is futile: you don't need abstract factories in Haskell. But that aside, here's why your particular attempt doesn't compile.

---

The signature

  createProduct :: Product p => f -> p

means not what you apparently think: in Java, this would say "I'll generate some object of a subclass of Product, don't ask which though." In Haskell – whose subclasses are not subtypes! – this means, "for any (specific!) instance of Product that you request, I'll give you an object of that concrete type." Which isn't possible, since FirstFactory apparently can't supply a SecondProduct.

To express what you tried to say, you need an explicit wrapper to contain "any subclass". We call that an existential, it's written thus:

{-# LANGUAGE GADTs       #-}

data AnyProduct where
  AnyProduct :: Product p => p -> AnyProduct

with this, you can write

class Factory f where
  createProduct :: f -> AnyProduct

For some yourProduct :: AnyProduct, you can then "call the toString method" this way:

      ...
      productString = case yourProduct of
                        AnyProduct p -> toString p
      ...

But since this is actually the only thing you can do with an AnyProduct value (like in OO language, you can't access fields/methods of the unknown subclass), the whole AnyProduct type is actually completely equivalent to String alone! And by the same argument, AnyFactory would again be equivalent to that. So basically, the entire code you posted is equivalent to

type Product = String

...

Existentials are quite generally frowned upon, you should only use them in special cases, not for anything just because OO languages do it with subclassing.