功能组成和forall'ed类型

Question

假设我们有一些像这样的代码，哪些类型很好：

{-# LANGUAGE RankNTypes #-}

data Foo a

type A a = forall m. Monad m => Foo a -> m ()
type PA a = forall m. Monad m => Foo a -> m ()
type PPFA a = forall m. Monad m => Foo a -> m ()

_pfa :: PPFA a -> PA a
_pfa = _pfa

_pa :: PA a -> A a
_pa = _pa

_pp :: PPFA a -> A a
_pp x = _pa $ _pfa x

main :: IO ()
main = putStrLn "yay"

我们注意到_pp x = _pa $ _pfa x太冗长了，我们尝试用_pp = _pa . _pfa替换它_pp = _pa . _pfa _pp = _pa . _pfa 。 突然，代码不再进行类型检查，失败的错误消息类似于

• Couldn't match type ‘Foo a0 -> m0 ()’ with ‘PA a’
  Expected type: (Foo a0 -> m0 ()) -> Foo a -> m ()
    Actual type: PA a -> A a

我想这是因为类型别名的定义中的m是forall - 实际上，用某种确切的类型替换m修复了这个问题。 但问题是：为什么forall在这种情况下破坏事情？

试图找出为什么用通常的_pfa = undefined替换_pfa和_pa虚拟递归定义的_pfa导致GHC抱怨统一变量和不可预测的多态性：

• Cannot instantiate unification variable ‘a0’
  with a type involving foralls: PPFA a -> Foo a -> m ()
    GHC doesn't yet support impredicative polymorphism
• In the expression: undefined
  In an equation for ‘_pfa’: _pfa = undefined

Answer 1

只是要清楚，当你写：

_pa :: PA a -> A a

编译器扩展类型同义词，然后向上移动量词和约束，如下所示：

_pa
  :: forall a.
     (forall m1. Monad m1 => Foo a -> m1 ())
  -> (forall m2. Monad m2 => Foo a -> m2 ())

_pa
  :: forall m2 a. (Monad m2)
  => (forall m1. Monad m1 => Foo a -> m1 ())
  -> Foo a -> m2 ()

所以_pa有一个rank-2多态类型，因为它有一个嵌套在函数箭头左边的forall。 _pfa 。 他们期望多态函数作为参数。

要回答实际问题，我首先会向您展示一些奇怪的东西。 这些都是typecheck：

_pp :: PPFA a -> A a
_pp x = _pa $ _pfa x

_pp :: PPFA a -> A a
_pp x = _pa (_pfa x)

但是，这不是：

apply :: (a -> b) -> a -> b
apply f x = f x

_pp :: PPFA a -> A a
_pp x = apply _pa (_pfa x)

不直观，对吗？ 这是因为应用程序运算符($)在编译器中是特殊的，以允许使用多态类型实例化其类型变量，以便支持runST $ do { … }而不是runST (do { … }) 。

然而，组合(.)不是特殊的。 所以当你在_pa和_pfa上调用(.)时，它首先实例化它们的类型。 因此，您最终尝试将错误消息中提到的类型(Foo a0 -> m0 ()) -> Foo a -> m ()的_pfa的非多态结果传递给函数_pa ，但它期望类型为P a的多态参数，因此会出现统一错误。

undefined :: a没有类型检查因为它试图用多态类型实例化a ，这是一个impregicative polymorphism的实例。 这是一个提示，你应该做的，什么样的隐藏非直谓性的标准方法是用newtype包装：

newtype A a = A { unA :: forall m. Monad m => Foo a -> m () }
newtype PA a = PA { unPA :: forall m. Monad m => Foo a -> m () }
newtype PPFA a = PPFA { unPPFA :: forall m. Monad m => Foo a -> m () }

现在这个定义编译没有错误：

_pp :: PPFA a -> A a
_pp = _pa . _pfa

使用显式包装和解包所需的成本来告诉GHC何时抽象和实例化：

_pa :: PA a -> A a
_pa x = A (unPA x)

Answer 2

使用多态类型实例化多态类型变量称为impredicative polymorphism。 - GHC用户指南

如错误消息所示，GHC仅允许使用单态，秩0类型实例化类型变量。 我的猜测是，使用impregicative polymorphism进行类型检查比实际看起来更难实现。