Haskell函数中的通用类型与刚性类型

Question

为什么 ghc 不抱怨以下函数中的类型是刚性的？

play :: (Monad m, MonadIO m, Random a) => a -> a -> m a
play r1 r2 = do
  randomRIO (r1, r2)

在上述情况下，m 实际上是IO。此代码编译。而其他时候，当我在泛型函数中使用具体类型时，ghc 会抱怨我使用的是具体类型。我错过了什么吗？

例如，如果我说：

play :: (Monad m, MonadIO m, Random a) => a -> a -> m a
play r1 r2 = do
  randomRIO (1, 6::Int)

这一次 ghc 抱怨我使用的是刚性类型。困扰我的是IO 在某种程度上是具体的或刚性的类型，因为它是IO 而不是Maybe。

编辑 1： 编译无误的完整代码：

{-# LANGUAGE ConstraintKinds #-}
module Main where

-- showing how to program in the mtl style
import           Control.Monad.IO.Class
import           System.Random

type Game m a = (Monad m, MonadIO m, Random a, Show a)

-- step 1
play :: (Game m a) => a -> a -> m a
play r1 r2 = do
  yell "hi"
  randomRIO (r1, r2)
  --rollDice r1 r2

-- step 2
yell :: (MonadIO m) => String -> m ()
yell str = liftIO $ putStrLn str

-- step 3
rollDice :: (Game m a) =>  a -> a ->  m a
rollDice a1 a2 = liftIO $ randomRIO (a1,a2)

main :: IO ()
main = putStrLn ""
-- main :: IO ()
-- main = do
--   play 1 (6::Int) >>= print
--   play 'a' 'z' >>= print
--   putStrLn "done"

Code that doesn't compile:

{-# LANGUAGE ConstraintKinds #-}
module Main where

-- showing how to program in the mtl style
import           Control.Monad.IO.Class
import           System.Random

type Game m a = (Monad m, MonadIO m, Random a, Show a)

-- step 1
play :: (Game m a) => a -> a -> m a
play r1 r2 = do
  yell "hi"
  randomIO 'a' 'z'
  --rollDice r1 r2

-- step 2
yell :: (MonadIO m) => String -> m ()
yell str = liftIO $ putStrLn str

-- step 3
rollDice :: (Game m a) =>  a -> a ->  m a
rollDice a1 a2 = liftIO $ randomRIO (a1,a2)

main :: IO ()
main = putStrLn ""
-- main :: IO ()
-- main = do
--   play 1 (6::Int) >>= print
--   play 'a' 'z' >>= print
--   putStrLn "done"

这不能编译：

{-# LANGUAGE ConstraintKinds #-}
module Main where

-- showing how to program in the mtl style
import           Control.Monad.IO.Class
import           System.Random

type Game m a = (Monad m, MonadIO m, Random a, Show a)

-- step 1
play :: (Game m a) => a -> a -> m a
play r1 r2 = do
  yell "hi"
  **randomRIO (1, 6::Int)**
  --rollDice r1 r2

-- step 2
yell :: (MonadIO m) => String -> m ()
yell str = liftIO $ putStrLn str

-- step 3
rollDice :: (Game m a) =>  a -> a ->  m a
rollDice a1 a2 = liftIO $ randomRIO (a1,a2)

main :: IO ()
main = putStrLn ""
-- main :: IO ()
-- main = do
--   play 1 (6::Int) >>= print
--   play 'a' 'z' >>= print
--   putStrLn "done"

更新

刚刚意识到我的困惑来自于阅读了错误的 random 文档 在我的代码中使用random-1.2 时，我正在阅读random-1.1 文档。

供大家参考：

random-1.1
randomRIO :: (a, a) -> IO a

random-1.2
randomRIO :: (Random a, MonadIO m) => (a, a) -> m a  

Answer 1

我猜你正在使用random-1.2，它使用更通用的randomRIO 类型。

在更新后的包中，randomRIO 在 monad m 和值类型 a 上都是多态的。它的类型是：

randomRIO :: (Random a, MonadIO m) => (a, a) -> m a 

所以，当你写的时候（为了清晰起见重命名类型变量）

play :: (Monad m1, MonadIO m1, Random a1) => a1 -> a1 -> m1 a1
play r1 r2 = do
  randomRIO (r1, r2)

GHC 推断出m a ~ m1 a1，这意味着m ~ m1 和a ~ a1，因此使用这些类型参数调用randomRIO（m 和a 在此处不是严格的）。请注意，IO 根本不涉及这里：m 可以是 IO，但也可以是任何其他 monad（在 MonadIO 类中）。

相反，当你写作时

play :: (Monad m1, MonadIO m1, Random a1) => a1 -> a1 -> m1 a1
play r1 r2 = do
  randomRIO (1, 6::Int)

GHC 再次推断m a ~ m1 a1，因此推断m ~ m1 和a ~ a1，但也推断a ~ Int，因为我们将一对Ints 传递给randomRIO。从a ~ a1 和a ~ Int 我们推断a1 ~ Int 会触发类型错误，因为a1 是刚性的。

如果我们只有一个更具体的 randomRIO 类型（例如我们在 random-1.2 之前的类型）

randomRIO :: (Random a) => (a, a) -> IO a

那么你的推理是正确的：我们会在类型推断期间得到m1 ~ IO，这会导致错误，因为m1 是刚性的。我们没有得到这个，因为randomRIO 更笼统。