Haskell 中的抽象工厂

Question

我想知道如何在函数式语言中实现抽象工厂设计模式，这在面向对象语言中很常见。特别是，我对 Haskell 实现感兴趣。

我尝试使用类型类来实现该模式：

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

编译此代码时，会返回以下错误：

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

编译器似乎对createProduct 的实现不满意，尤其是它的返回值。我虽然返回 Product 类型类的任何实例都可以解决问题，但显然不行。

我想知道是否可以在 Haskell 中实现类似于抽象工厂的东西，或者我的方法是否完全错误。我可以使用其他“模式”来获得类似的结果吗？

编辑

根据leftaroundabout的建议和解释，我想出了一个不同的解决方案，在不滥用类型类的情况下满足我的需求。解决方案可能会有所改进，但目前这是我能做到的最好的。

库必须定义类似于以下内容的内容：

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

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

该库的一些用户可以提供ProductSystem 的“实现”以满足他们的具体需求：

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"

在其他地方，这两个部分可以统一执行所需的行为：

productUser firstSystem
productUser secondSystem

Answer 1

正如我已经评论过的，整个想法是徒劳的：你不需要 Haskell 中的抽象工厂。但除此之外，这就是您的特定尝试无法编译的原因。

---

签名

  createProduct :: Product p => f -> p

的意思显然不是你想的那样：在 Java 中，这会说“我将生成 Product 的子类的一些对象，但不要问是哪个。”在 Haskell 中——它的子类是 not 子类型！ – 这意味着，“对于您请求的 任何（具体！）Product 实例，我会给您一个具体类型的对象。”这是不可能的，因为FirstFactory 显然无法提供SecondProduct。

为了表达你想说的话，你需要一个显式的包装器来包含“任何子类”。我们称之为existential，它是这样写的：

{-# LANGUAGE GADTs       #-}

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

有了这个，你就可以写了

class Factory f where
  createProduct :: f -> AnyProduct

对于某些yourProduct :: AnyProduct，您可以这样“调用toString 方法”：

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

但由于这实际上是唯一您可以使用 AnyProduct 值（就像在 OO 语言中，您不能访问未知子类的字段/方法），整个 @ 987654333@ 类型实际上完全等同于单独的String！通过同样的论点，AnyFactory 将再次等价于那个。所以基本上，你发布的整个代码相当于

type Product = String

...

Existentials 相当 generally frowned upon，你应该只在特殊情况下使用它们，而不是仅仅因为 OO 语言通过子类化来实现它。