多态模式匹配导致类型不明确

（灵感来自无法匹配具有约束的多态元组 https://stackoverflow.com/questions/57137421/cannot-match-on-polymorphic-tuples-with-constraints，并基于随后的comment https://stackoverflow.com/questions/57137421/cannot-match-on-polymorphic-tuples-with-constraints#comment100805403_57138105根据我自己的回答。）

考虑以下最小示例：

test :: (Show a, Show b) => (a -> String, b -> String)
test = (show,show)

(resX, resY) = test

这会导致以下错误：

    • Ambiguous type variable ‘a0’ arising from a use of ‘test’
      prevents the constraint ‘(Show a0)’ from being solved.
      Relevant bindings include
        resX :: a0 -> String (bound at so.hs:25:2)
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      These potential instances exist:
        instance Show Ordering -- Defined in ‘GHC.Show’
        instance Show Integer -- Defined in ‘GHC.Show’
        instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
        ...plus 22 others
        ...plus 17 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the expression: test
      In a pattern binding: (resX, resY) = test
   |
25 | (resX, resY) = test
   |                ^^^^

这是有道理的：模式匹配不会受到限制a or b无论如何，所以他们是模棱两可的。但我该如何摆脱这个错误呢？几乎每次尝试通过添加类型签名来解决此问题都会产生另一个错误。例如：

-- attempt 1
test :: (Show a, Show b) => (a -> String, b -> String)
test = (show,show)

resX :: Show a => a -> String
resY :: Show b => b -> String
(resX, resY) = test

-- attempt 2
test :: (Show a, Show b) => (a -> String, b -> String)
test = (show,show)

(resX, resY) = test :: (Show a, Show b) => (a -> String, b -> String)

那么：我怎样才能摆脱歧义错误呢？而为什么上述尝试都失败了呢？

思考代码在运行时的实际工作原理很有启发性。类型类有字典传递语义。优雅的代码

class Foo a where
    foo :: a -> Int

instance Foo Int where
    foo = id

useFoo :: Foo a => a -> IO ()
useFoo x = print (foo x)

callFoo = useFoo (123 :: Int)

被编译成非类代码。

data Foo_ a = Foo_ { foo :: a -> Int }

foo_Int :: Foo_ Int
foo_Int = Foo_ { foo = id }

useFoo :: Foo_ a -> a -> IO ()
useFoo dict x = print (foo dict x)

callFoo = useFoo foo_Int 123

“胖箭”=>在运行时实际上意味着与“瘦骨嶙峋的箭头”完全相同的东西->。唯一的区别是=>的参数由约束求解器隐式传递。

所以让我们想想你的Show从这个角度看例子。像这样的类型test :: (Show a, Show b) => (a -> String, b -> String)真正意思test :: (Show_ a, Show_ b) -> (a, String, b -> String)。您不能将该函数分解为一对函数(Show_ a -> a -> String, Show_ b -> b -> String)。函数体可能会同时使用两者Show_返回结果之前必须先提供字典，因此您必须先提供两者，然后才能获得(a -> String, b -> String) out.

当推断类型时resx，类型检查器会得出resx :: (Show a, Show b) => a -> String- 它需要范围内的两个实例才能调用test。显然这是一种模棱两可的类型。b没有出现在右侧=>, so at resx的调用站点永远不会有足够的本地类型信息来成功调用它。

你可能会反对那个should在这种情况下能够进行这样的因式分解。的两半test身体不能互相利用Show实例，因为Show的方法仅将其类型参数作为输入进行讨论，并且输入不在元组错误的一半范围内。但这是关于运行时行为的参数化的复杂论证，并且仅适用于这种特定情况。这不是编译器擅长的那种愚蠢的语法指导推理。