将返回类型限制为 Context

Question

这是我目前的尝试：

module Main where

data FooT = One | Two deriving (Show, Read)
{-
That is what I want
foo :: (Show a, Read a) => a
foo = One
-}

--class Footable (Show a, Read a) => a where
class Footable a where
  --foo2 :: (Show a, Read a) => a
  foo2 :: a

instance Footable FooT where
  foo2 = One

-- test = print foo2

我想编译测试。我认为问题不在于普遍量化。 ghc 说 a 是一个“严格类型变量”edit（rigid 类型变量），但我并不真正理解这是什么。这个问题好像和this有关

编辑

正如我在@sepp2k 的评论中所写，这可能与存在类型有关，但我偶然发现了一种奇怪的行为：

这确实编译：

{-# LANGUAGE OverlappingInstances, FlexibleInstances, OverlappingInstances,
UndecidableInstances, MonomorphismRestriction, PolymorphicComponents #-}
{-# OPTIONS_GHC -fno-monomorphism-restriction #-}

module Main where

    class (Num a) => Numable a where
      foo2 :: a

    instance (Num a) => Numable a where
      foo2 = 1

    instance Numable Int where
      foo2 = 2

    instance Numable Integer where
      foo2 = 3

    --test = foo2 + foo2 -- This does NOT compile (ambiguous a) 
    test = (foo2::Integer) + foo2 --this works

但这不是（`a' 是刚性类型变量消息）

{-# LANGUAGE OverlappingInstances, FlexibleInstances, OverlappingInstances,
UndecidableInstances, MonomorphismRestriction, PolymorphicComponents #-}
{-# OPTIONS_GHC -fno-monomorphism-restriction #-}

module Main where

    data FooT = One | Two deriving (Show, Read)
    data BarT = Ten deriving (Show, Read)

    class (Show a, Read a) => Footable a where
      foo2 :: a

    instance (Show a, Read a) => Footable a where
      foo2 = Ten

    instance Footable FooT where
      foo2 = One

    main = print foo2

之所以如此，是因为 1 :: (Num t) => t。我可以这样定义一些东西（类型构造函数，consts 不知道）吗？

Answer 1

当我取消注释 test 的定义并尝试编译您的代码时，我得到“模糊类型变量”。与严格无关。要理解为什么这是模棱两可的考虑这个：

module Main where

data FooT = One | Two deriving (Show, Read)
data BarT = Three | Four deriving Show

class Footable a where
  foo2 :: a

instance Footable FooT where
  foo2 = One

instance Footable BarT where
  foo2 = Three

main = print foo2  -- Should this print One or Three?

当然，在您的代码中只有一个 Footable 实例，因此 Haskell 理论上可以推断您想要使用为 FooT 定义的 foo2，因为这是范围内的唯一实例。但是，如果这样做了，代码会在您导入恰好定义另一个 Footable 实例的模块时中断，因此 haskell 不会这样做。

要解决您的问题，您需要使用其类型注释 foo2，如下所示：

module Main where

data FooT = One | Two deriving (Show, Read)

class Footable a where
  foo2 :: a

instance Footable FooT where
  foo2 = One

main = print (foo2 :: FooT)

要求所有 Footables 都是 Show 和 Read 的实例，只需执行以下操作：

class (Show a, Read a) => Footable a where
  foo2 :: a

就像您在 cmets 中所做的那样，但没有在 foo2 的签名中再次指定约束。

Answer 2

正如 sepp2k 所说，Ghc 无法猜测 foo2 的返回类型。做约束它（这是你的问题的标题）添加一个内联类型签名。

test = print (foo2 :: FooT)