Question

这些之间有什么区别？

{-# LANGUAGE RankNTypes #-}

f :: forall a. a -> Int
f _ = 1

g :: (forall a. a) -> Int
g _ = 1

特别是，为什么我会在g ()时收到错误？

ghci> f ()
1
ghci> g ()
<interactive>:133:3:
    Couldn't match expected type `a' with actual type `()'
      `a' is a rigid type variable bound by
          a type expected by the context: a at <interactive>:133:1
    In the first argument of `g', namely `()'
    In the expression: g ()
    In an equation for `it': it = g ()

ghci> f undefined
1
ghci> g undefined
1

Answer 1

f只是一个普通的多态Haskell98函数，除了显式写出forall。因此签名中的所有类型变量都是调用者可以选择的参数（没有任何约束）;在你的情况下，它已经解决了a ~ ()。

g OTOH的等级为2级。它要求其参数具有多态类型forall a . a。 ()没有这种类型，它是单形的。但是，如果我们再次添加显式undefined，则forall具有此类型（事实上，仅未定义，错误等）。

也许用一个不那么简单的Rank2函数会变得更清晰：

h :: (forall a . (Show a, Num a) => a) -> String
h a = show a1 ++ " :: Double\n"
     ++ show a2 ++ " :: Int"
 where a1 :: Double; a2 :: Int
       a1 = a; a2 = a

GHCI＆GT; putStrLn $ h 4
4.0 ::双倍 4 :: Int

但我做不到

GHCI＆GT; putStrLn $ h（4 :: Integer）

  ＆LT;互动＆GT：4：15：
  无法演绎（a~Integer）
  从上下文（显示，数字a）
  受上下文预期的类型约束:(显示a，Num a）=＆gt;一个
  at＆lt; interactive＆gt;：4：12-27
  `a'是由
绑定的刚性类型变量   上下文所期望的类型:(显示a，Num a）=＆gt;一个
  at＆lt; interactive＆gt;：4：12
  在'h'的第一个参数中，即`（4 :: Integer）'   在`（$）'的第二个参数中，即`h（4 :: Integer）'   在表达式中：putStrLn $ h（4 :: Integer）

Answer 2

将forall视为匿名类型函数。 Haskell中类型签名中具有类型变量的所有数据类型都隐式具有forall。例如，考虑：

f :: a -> Int
f _ = 1

上面的函数f接受任何类型的参数并返回Int。 a来自哪里？它来自forall量词。因此它相当于：

f :: (forall a . a -> Int)
f _ = 1

forall quatifier可用于任何数据类型，而不仅仅是函数。例如，考虑以下值的类型：

() :: ()
10 :: Int
pi :: Floating a => a

这里()和10是单形的（即它们只能是一种具体类型）。另一方面，pi具有类型类约束的多态性（即，只要该类型是Floating的实例，它就可以是任何类型）。明确写出的pi类型为：

pi :: (forall a . Floating a => a)

同样，forall量词就像一个类型函数。它为您提供了类型变量a。现在考虑函数类型g：

g :: (forall a . a) -> Int
g _ = 1

此处g需要forall a . a类型的参数并返回Int。这是g ()不起作用的原因：()属于()类型，而不属于forall a . a类型。事实上，forall a . a类型的唯一值是undefined：

undefined :: a

使用forall明确写出：

undefined :: (forall a . a)

如果您注意到我总是在forall量化周围加上括号。我这样做的原因是为了向您展示当您对函数使用forall量化时，量化一直延伸到右侧。这就像一个lambda：如果你没有在lambda周围加上括号，Haskell会将lambda函数一直扩展到右边。因此，f的类型为(forall a . a -> Int)而不是(forall a . a) -> Int。

请记住，在第一种情况下，Haskell期望参数的类型为a（即任何东西）。但是在第二种情况下，Haskell期望参数的类型为(forall a . a)（即undefined）。当然，如果您尝试评估undefined，那么您的程序将立即停止并出现错误。幸运的是，你不是要评估它。

RankNTypes和范围'forall'

2 个答案: