双向功能依赖

Question

我有一个类似于以下类型的类：

class Foo a b | a -> b where
  f :: a -> Bool
  g :: b -> Bool
  h :: a -> b -> Bool

或者至少这些对我的问题很重要。 这个类没有编译，并且有充分的理由。 这个类的问题是我可以（如果我想）执行以下操作：

instance Foo () Bool where
  f x = True
  g y = y
  h x y = False

instance Foo ((), ()) Bool where
  f x = True
  g y = not y
  h x y = False

现在，如果我调用g True ，则每个实例都有两个单独的结果。 编译器接受了这种可能性，并告诉我我的类型类没有用。

我的问题是依赖| a -> b | a -> b不是我的意思。 我不仅仅意味着你可以找到a来自b ，而且你可以从a找到b 。 这是每种类型应该只是Foo一个成员与另一种类型，所以我们可以给一种类型找到另一种。 或者换句话说，依赖是双向的。 这样的函数依赖将阻止我在两个单独的实例中存在Bool ，因为第一个参数可以从第二个参数派生，也可以从第一个参数派生。

但我不知道如何向编译器表达这个想法。

如何创建双向功能依赖？ 或者，更有可能的是，有没有一种方法可以重新定义我的类型类以获得可以取代双向函数依赖的东西？

Answer 1

a和b之间a 双向依赖关系可以表示为两个函数依赖关系a -> b和b -> a ，如：

class Foo a b | a -> b, b -> a where
  f :: a -> Bool
  g :: b -> Bool
  h :: a -> b -> Bool

所以这里a是功能依赖于b而b是功能依赖于a 。

然而，对于你的instance来说，这当然会引发一个错误，因为现在你为b ~ Bool定义了两个不同a s。 这会引发如下错误：

file.hs:6:10: error:
    Functional dependencies conflict between instance declarations:
      instance Foo () Bool -- Defined at file.hs:6:10
      instance Foo ((), ()) Bool -- Defined at file.hs:11:10
Failed, modules loaded: none.

由于函数依赖性，您只能为b ~ Bool定义一个a 。 但这可能正是您正在寻找的：一种机制，可以防止为同a或同一个b定义Foo两次。

Answer 2

（这更多的是评论而不是答案，因为它没有解决OP提出的确切问题。）

为了补充Willem的答案：现在我们有另一种方法让GHC接受这个课程。

class Foo a b | a -> b where
  f :: a -> Bool
  g :: b -> Bool
  h :: a -> b -> Bool

正如GHC在其错误消息中建议的那样，我们可以打开AllowAmbiguousTypes 。 OP注意到，如果我们评估类似g False东西，那么就会遇到麻烦，并且有两个匹配的实例

instance Foo () Bool where
  f x = True
  g y = y
  h x y = False

instance Foo ((), ()) Bool where
  f x = True
  g y = not y
  h x y = False

实际上，在这种情况下， g False变得模棱两可。 然后我们有两个选择。

首先，我们可以通过在类中添加函数依赖关系b -> a来禁止同时使用上述两个实例（如Willem建议的那样）。 这使得g False明确无误（在这种情况下我们不需要扩展）。

或者，我们可以在代码中保留两个实例，并使用类型应用程序（另一个扩展名）消除调用g False歧义。 例如， g @() False选择第一个实例，而g @((),()) False选择第二个实例。

完整代码：

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies,
    FlexibleInstances, AllowAmbiguousTypes, TypeApplications #-}

class Foo a b | a -> b where
  f :: a -> Bool
  g :: b -> Bool
  h :: a -> b -> Bool

instance Foo () Bool where
  f x = True
  g y = y
  h x y = False

instance Foo ((), ()) Bool where
  f x = True
  g y = not y
  h x y = False

main :: IO ()
main = print (g @() False, g @((),()) False)

Answer 3

Willem Van Onsem的回答几乎就是我想要的，但还有另一种方式我意识到可能值得一提。 为了获得预期的行为，我们实际上可以将我们的类分成多个类。 有几种方法可以做到这一点，最好的选择可能取决于细节。 但是这里有一种方法可以解决问题中的代码：

class Bar b where
  g :: b -> Bool

class (Bar b) => Foo a b | a -> b where
  f :: a -> Bool
  h :: a -> b -> Bool

现在我们仍然允许我们使用相同的b创建两个不同的Foo实例，但是我们不再明白这一点，因为g现在是Bar的成员，两者之间必须有一个实例。

这通常可以通过移动可能不明确的函数并将其移动到单独的类类来完成。

另一种方法我们可以使用其他类型类来创建第二个类来强制实现双向性。 对于示例，这将看起来像：

class Bar a b | b -> a

class (Bar a b) => Foo a b | a -> b where
  f :: a -> Bool
  g :: b -> Bool
  h :: a -> b -> Bool

这里Bar的行为，使b依赖于a阻止我们具有不确定性。 由于Foo要求Bar和Bar允许a将被衍生自b ，的任何实例Foo允许a将被衍生自b 。 这几乎是我原本想要的，但它只是Willem Van Onsem答案的一个稍微复杂的版本。