haskell - 我如何向 GHC 证明 (b ~ Foo)？

Question

新问题

我不会假装我知道如何思考或谈论 haskell。在伪 java-oo-行话中:

我想要做的是拥有一个“实现”“接口(interface)”的“结构”。该接口(interface)的一部分是一个函数，该函数返回一个实现另一个接口(interface)的对象。

interface IFiz {}

interface IBuz {
    function IFiz getFiz() 
}

class Foo implements IFiz { ... }
class Bar implements IBuz {
    IFiz fiz = new Foo();
    function getFiz() {
        return fiz;
    }
}

我如何在 Haskell 中执行此操作？我的尝试如下所述。

---

老问题

我如何向 GHC 证明 (b ~ Foo)？

我对问题的理解:

Foo 是类型类 Fiz 的实例。

我希望 Bar 成为类型类 Buz 的一个实例。

但是，编译器无法在 punk 方法的实现中推断出 (b ~ Foo)。但它还能是什么呢？我尝试使用已弃用的直接方式以及使用 GADT 添加数据约束，但似乎都不起作用(我继续得到完全相同的错误。)

data Foo = Foo Int                                                                                                                                                                                                                           
data Bar = Bar Foo                                                                                                                                                                                                                           
                                                                                                                                                                                                                                           
class Fiz a where                                                                                                                                                                                                                            
    funk :: a -> a -- Not important, I just wanted to put something in Fiz                                                                                                                                                                                                                           
                                                                                                                                                                                                                                           
class Buz a where                                                                                                                                                                                                                            
    punk :: Fiz b => a -> b                                                                                                                                                                                                                  
                                                                                                                                                                                                                                           
instance Fiz Foo where                                                                                                                                                                                                                       
    funk a = a                                                                                                                                                                                                                               
                                                                                                                                                                                                                                           
instance Buz Bar where                                                                                                                                                                                                                       
   punk (Bar foo) = foo

---

Could not deduce (b ~ Foo)
from the context (Fiz b)
  bound by the type signature for punk :: Fiz b => Bar -> b
  at Test.hs:42:5-8
  ‘b’ is a rigid type variable bound by
      the type signature for punk :: Fiz b => Bar -> b at Test.hs:42:5
Relevant bindings include punk :: Bar -> b (bound at Test.hs:42:5)
In the expression: foo
In an equation for ‘punk’: punk (Bar foo) = foo

Answer 1

这种类型的签名:

class Buz a where
  punk :: Fiz b => a -> b

表示 punk 必须能够为任何类型 b 返回类型 b 的东西，因为它是 Fiz< 的实例。所以问题不在于编译器无法推断出 Foo 是 Fiz 的实例，而是返回值不是 Quux，它是一个实例的 Fiz。

data Quux = Quux 

instance Fiz Quux where
  funk a = a

如果你想要类型类的函数返回任何 Fiz 的实例，你可以使用 ExistentionalQuantification 扩展:

{-# LANGUAGE RankNTypes, ExistentialQuantification #-}   
data Foo = Foo Int
data Bar = Bar Foo
data SomeFiz = forall a . Fiz a => SomeFiz a
class Fiz a where
  funk :: a -> a

class Buz a where
  punk :: a -> SomeFiz

instance Fiz Foo where
  funk a = a

instance Buz Bar where
  punk (Bar foo) = SomeFiz foo

否则，如果你真的想实现这个类型类，你只能通过将 bottoms 传递给 funk 来实现:

instance Buz Bar where
  punk _ = funk undefined
-- or for example:
instance Buz Bar where
  punk _ = funk (funk undefined)

或通过修复 funk:

instance Buz Bar where
  punk _ = fix funk

如果您能提供更多有关您想要实现的目标的详细信息，也许我能够提供更有帮助的答案。