如何以类似于其他语言中的 mixins/方法修饰符/traits 的方式促进代码重用？

Question

我正在编写一些与数据库模式接口的代码，该数据库模式对持久图进行建模。在详细讨论我的具体问题之前，我认为这可能有助于提供一些动力。我的架构围绕着书籍、人物和作者角色。一本书有许多作者角色，每个角色都有一个人。但是，您必须创建一本新书并对新版本进行修改，而不是允许对书籍对象进行直接 UPDATE 查询。

现在，回到哈斯克尔土地。我目前正在使用一些类型类，但重要的是我有 HasRoles 和 Entity：

class HasRoles a where
    -- Get all roles for a specific 'a'
    getRoles :: a -> IO [Role]

class Entity a where
    -- Update an entity with a new entity. Return the new entity.
    update :: a -> a -> IO a

这就是我的问题。当您更新书籍时，您需要创建新的书籍版本，但您还需要复制以前的书籍角色（否则您会丢失数据）。最简单的方法是：

instance Entity Book where
    update orig newV = insertVersion V >>= copyBookRoles orig

这很好，但有件事让我烦恼，那就是缺乏对不变量的任何保证，即如果某物是实体并且 HasRoles，然后插入新版本将复制现有角色。我想到了 2 个选项：

使用更多类型

一个“解决方案”是引入 RequiresMoreWork a b。从上面开始，insertVersion 现在返回一个 HasRoles w =>;需要更多工作与书籍。 update 想要一个 Book，因此为了摆脱 RequiresMoreWork 值，我们可以调用 workComplete :: RequiresMoreWork () Book -> ;预订。

但真正的问题是，这个难题中最重要的部分是 insertVersion 的类型签名。如果这与不变量不匹配（例如，它没有提到需要 HasRoles），那么一切都会再次崩溃，我们又会回到违反不变量的情况。

使用 QuickCheck 证明这一点

将问题移出了编译时间，但至少我们仍然断言不变量。在这种情况下，不变量类似于：对于同时也是 HasRoles 实例的所有实体，插入现有值的新版本应该具有相同的角色。

---

我对此有点困惑。在 Lisp 中我会使用方法修饰符，在 Perl 中我会使用角色，但是在 Haskell 中我可以使用什么吗？

Answer 1

处理具体问题时，我会将角色作为类型的一部分，而不是类

数据 Rolled a = Rolled a [Role]

实例 Entity a =>实体（卷起）
其中 update (Rolled a rs) = Rolled (update a) rs

更一般地说，你可以只创建 Entity 的实例对

，我还没有达到 haskell zen，但我猜你最终应该在 Writer 或 State monad 中工作（或者他们的变压器版本）

Answer 2

对于如何回应这个问题，我有两种想法：

这很好，但有一些东西让我烦恼，那就是缺乏
任何不变量的保证，如果某物是一个实体并且
HasRoles，然后插入新版本将复制现有版本
角色。

一方面，如果某个东西是实体，那么它是否具有角色并不重要。您只需提供更新代码，它对于该特定类型应该是正确的。

另一方面，这确实意味着您将为每种类型复制 copyRoles 样板，并且您当然可能会忘记包含它，因此这是一个合理的问题。

当您需要这种性质的动态分派时，一种选择是使用 GADT 来覆盖类上下文：

class Persisted a where
    update :: a -> a -> IO a

data Entity a where
    EntityWithRoles :: (Persisted a, HasRoles a) => a -> Entity a
    EntityNoRoles   :: (Persisted a) => a -> Entity a

instance Persisted (Entity a) where
    insert (EntityWithRoles orig) (EntityWithRoles newE) = do
      newRoled <- copyRoles orig newE
      EntityWithRoles <
gt; update orig newRoled
    insert (EntityNoRoles orig) (EntityNoRoles newE) = do
      EntityNoRoles <
gt; update orig newE

但是，考虑到您所描述的框架，您可以不使用 update 类方法，有一个 save 方法，其中 update 是一个普通函数，

class Persisted a where
    save :: a -> IO ()

-- data Entity as above

update :: Entity a -> (a -> a) -> IO (Entity a)
update (EntityNoRoles orig) f = let newE = f orig in save newE >> return (EntityNoRoles newE)
update (EntityWithRoles orig) f = do
  newRoled <- copyRoles orig (f orig)
  save newRoled
  return (EntityWithRoles newRoled)

我希望它的一些变体更容易使用。

类型类和 OOP 类之间的主要区别是类型类方法不提供任何代码重用方法。为了重用代码，您需要将共性从类型类方法中提取出来并放入函数中，就像我在第二个示例中使用 update 所做的那样。我在第一个示例中使用的另一种方法是将所有内容转换为某种通用类型 (Entity)，然后仅使用该类型。我希望第二个示例具有独立的 update 函数，从长远来看会更简单。

还有另一种选择可能值得探索。您可以将 HasRoles 设为 Entity 的超类，并要求所有类型都具有带有虚拟函数的 HasRoles 实例（例如 getRoles _ = return []） 。如果您的大多数实体无论如何都有角色，那么这实际上使用起来非常方便并且完全安全，尽管有些不优雅。