IO monad 的 >>= 和 return 的定义是什么？

Question

在看到 List 和 Maybe monad 是如何定义后，我自然好奇如何 >>= 和 return 操作是为 IO monad 定义的。

Answer 1

IO没有具体的实现；它是一个抽象类型，Haskell 报告未定义确切的实现。事实上，没有什么可以阻止将 IO 及其 Monad 实例实现为编译器原语的实现，而根本没有 Haskell 实现。

基本上，Monad 用作 IO 的接口，它本身无法在纯 Haskell 中实现。这可能就是您现阶段需要了解的全部内容，深入研究实现细节可能只会造成混乱，而不是提供洞察力。

也就是说，如果您查看 GHC 的源代码，您会发现它将 IO a 表示为一个类似于 State# RealWorld ->; 的函数。 (# State# RealWorld, a #) （使用拆箱元组 作为返回类型），但这是误导性的；这是一个实现细节，这些 State# RealWorld 值在运行时实际上并不存在。无论在理论上还是在实践中，IO不是一个状态单子¹。

相反，GHC 使用不纯原语来实现这些 IO 操作； State# RealWorld“值”只是通过引入从一个语句到下一个语句的数据依赖性来阻止编译器对语句重新排序。

但如果您确实想查看 GHC 的 return 和 (>>=) 实现，它们就是：

returnIO :: a -> IO a
returnIO x = IO $ \ s -> (# s, x #)

bindIO :: IO a -> (a -> IO b) -> IO b
bindIO (IO m) k = IO $ \ s -> case m s of (# new_s, a #) -> unIO (k a) new_s

其中 unIO 只是解开来自 IO 构造函数内部的函数。

需要注意的是，IO a 表示不纯计算的描述，可以运行该计算来生成 a 类型的值。事实上，有一种方法可以从 GHC 的 IO 内部表示中获取值，但这并不意味着这通常成立，或者您可以对所有 monad 执行这​​样的操作。这纯粹是 GHC 方面的实现细节。

¹ 状态 monad 是一个用于访问和改变一系列计算的状态；它表示为 s ->; (a, s) （其中 s 是状态类型），它看起来与 GHC 用于 IO 的类型非常相似，因此会造成混淆。

Answer 2

您会感到失望，但 IO monad 中的 >>= 并不是那么有趣。引用 GHC 源代码：

{- |
A value of type @'IO' a@ is a computation which, when performed,
does some I\/O before returning a value of type @a@.

There is really only one way to \"perform\" an I\/O action: bind it to
@Main.main@ in your program.  When your program is run, the I\/O will
be performed.  It isn't possible to perform I\/O from an arbitrary
function, unless that function is itself in the 'IO' monad and called
at some point, directly or indirectly, from @Main.main@.

'IO' is a monad, so 'IO' actions can be combined using either the do-notation
or the '>>' and '>>=' operations from the 'Monad' class.
-}
newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

这意味着 IO monad 被声明为 State State# monad 的实例，< Strike> 及其 >>= 在那里定义（并且其实现相当容易猜测）。

请参阅 Haskell wiki 上的 IO inside 文章，了解有关 <代码>IO单子。
查看 也很有帮助Haskell 文档，其中每个位置的右侧都有小的“源”链接。

更新：还有另一个令人失望的地方，这就是我的答案，因为我没有注意到 State# 中的“#”。
然而，IO 的行为类似于带有抽象 RealWorld 状态的 State monad，

正如@ehird 所写，State# 是编译器的内部，>= 的 IO monad 定义在 GHC.Base 模块：

instance  Monad IO  where
    {-# INLINE return #-}
    {-# INLINE (>>)   #-}
    {-# INLINE (>>=)  #-}
    m >> k    = m >>= \ _ -> k
    return    = returnIO
    (>>=)     = bindIO
    fail s    = failIO s

returnIO :: a -> IO a
returnIO x = IO $ \ s -> (# s, x #)

bindIO :: IO a -> (a -> IO b) -> IO b
bindIO (IO m) k = IO $ \ s -> case m s of (# new_s, a #) -> unIO (k a) new_s

Answer 3

它们不做任何特殊的事情，只是用于排序操作。如果您用不同的名称来考虑它们，将会有所帮助：

>>= 变为“然后，使用上一个操作的结果”

>>变成“然后”，

return 变成“什么也不做，但是什么都不做的结果是”

这就把这个函数变成：

main :: IO ()
main = putStr "hello"
   >>  return " world"
   >>= putStrLn

变成：

main :: IO ()
main = putStr "hello" and then,
       do nothing, but the result of doing nothing is " world"
       and then, using the result of the previous action, putStrLn

到最后，IO 并没有什么神奇之处。它就像 C 语言中的分号一样神奇。