代码之家  ›  专栏  ›  技术社区  ›  danbroooks

“IO”到底是如何在引擎盖下工作的?

  •  5
  • danbroooks  · 技术社区  · 8 年前

    当解释一个像 Monad 对于初学者来说,我认为避免使用任何复杂的Haskell术语或类似的范畴理论是有帮助的。我认为一个很好的解释是建立起一个功能的动机 a -> m b 以一种直截了当的方式 Maybe :

    data Maybe = Just a | Nothing
    

    要么全是,要么什么都不是。但是如果我们有一些功能 f :: a -> Maybe b 和 g :: b -> Maybe c 我们想要一个很好的方法把它们结合起来?

    andThen :: Maybe a -> (a -> Maybe b) -> Maybe b
    andThen Nothing _ = Nothing
    andThen (Just a) f = f a
    
    comp :: Maybe Text
    comp = f a `andThen` g
      where f g a = etc...
    

    然后你可以说 andThen 可以为各种类型(最终形成monad类型类)定义。。。下一个让我信服的例子是 IO . 但是你会怎么定义 以及 对于 输入输出 你自己?这就引出了我自己的一个问题。。。我天真地实现了 andThenIO 会是这样的:

    andThenIO :: IO a -> (a -> IO b) -> IO b
    andThenIO io f = f (unsafePerformIO io) 
    

    但我知道当你 >>= 使用 输入输出 . 着眼于 bindIO 在里面 GHC.Base 我看到这个:

    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 这:

    unIO :: IO a -> (State# RealWorld -> (# State# RealWorld, a #))
    unIO (IO a) = a
    

    似乎与 ST 莫纳德,尽管我知道 装货单 几乎什么都没有。。。我想我的问题是,我的天真实现和使用 装货单 ? 我的天真的实现在这个例子中有用吗?或者没有给出它实际上并没有在幕后进行(而且可能是一个误导性的解释)

    1 回复  |  直到 8 年前
        1
  •  10
  •   chi    8 年前

    (注:这是对“如何解释 IO 对初学者来说很有用。它并不试图解释 RealWorld# 黑客GHC使用。的确,后者不是一个好的介绍方式 输入输出 .)

    有很多方法可以向初学者解释IO monad。这很难,因为不同的人在心理上将单子与不同的想法联系在一起。您可以使用范畴理论,或者将它们描述为可编程分号,甚至 burritos .

    正因为如此,当我在过去尝试这样做的时候,我通常会尝试很多方法,直到其中一种方法“点击”到学习者的心理模式。了解他们的背景有很大帮助。

    命令闭包

    例如,当学习者已经熟悉一些带有闭包的命令式语言(例如JavaScript)时,我倾向于告诉他们,他们可以假装Haskell程序的全部目的是生成JavaScript闭包,然后使用JavaScript实现运行。在这个虚假的解释中 IO T type代表封装JavaScript闭包的不透明类型,在运行时,它将生成类型为 T ,可能是在引起一些副作用之后——就像JavaScript所做的那样。

    所以,一个值 f :: IO String 可实施为

    let f = () => {
        print("side effect");
        return "result";
        };
    

    和 g :: IO () 可实施为

    let g = () => {
        print("g here");
        return {};
        };
    

    现在,假设 f 闭包,如何从Haskell调用它?好吧,我们不能直接这么做,因为哈斯克尔想控制副作用。也就是说,我们不能 f ++ "hi" 或 f() ++ "hi" .

    相反,要“调用闭包”,我们可以将其绑定到 main

    main :: IO ()
    main = g
    

    的确, 主要的 是整个Haskell程序生成的JavaScript闭包,它将由Haskell实现调用。

    好的,现在的问题是:“如何调用多个闭包?”为此,可以介绍 >> 假装它是作为

    function andThenSimple(f, g) {
       return () => {
          f();
          return g();
          };
    }
    

    或者,为了 >>= :

    function andThen(f, g) {
       return () => {
          let x = f();
          return g(x)();  // pass x, and then invoke the resulting closure
          };
    }
    

    return 比较容易

    function ret(x) {
       return () => x;
    }
    

    这些函数需要一段时间才能解释,但如果理解闭包,就不难理解它们。

    纯功能(又名免费)

    另一个选择是保持一切纯洁。或者至少尽可能纯净。你可以假装 IO a 是不透明类型,定义为

    data IO a
       = Return a
       | Output String (IO a)
       | Input (String -> IO a)
       -- ... other IO operations here
    

    然后假装 main :: IO () 然后由某个命令引擎“运行”。像这样的程序

    foo :: IO Int
    foo = do
      l <- getLine
      putStrLn l
      putStrLn l
      return (length l)
    

    实际上,根据这个解释,

    foo :: IO Int
    foo = Input (\l -> Output l (Output l (Return (length l))))
    

    当然在这里 return = Return ,并定义 >>= 是个很好的锻炼。

    咖喱杂质

    忘了IO,monads,还有那些东西。我们可以更好地理解两个简单的概念

    a -> b   -- pure function type
    a ~> b   -- impure function type
    

    后者是一个假想的哈斯克尔类型。大多数程序员应该能够对这些类型表示的内容有很强的直觉。

    现在,在函数式编程中,我们有curring,它是

    (a, b) -> c
    

    和

    a -> b -> c
    

    经过一番思考,我们可以看到不纯洁的函数也应该承认一些讨好。我们确实可以确信,应该有一些类似于

    (a, b) ~> c
       <===>
    a ~> b ~> c
    

    再想一想,你甚至可以明白 ~> 在里面 a ~> b ~> c 实际上是不准确的。上面的curried函数在 a 只有一个人在过去——这是 b 这会触发原始未载波函数的执行,导致副作用。

    所以,考虑到这一点,我们可以认为咖喱是

    (a, b) ~> c
       <===>
    a -> b ~> c
    --^^-- pure!
    

    作为一个特殊的例子,我们得到了同构

    (a, ()) ~> c
       <===>
    a -> () ~> c
    

    更进一步,因为 (a, ()) 同构于 一 (这里需要更具说服力的解释),我们可以将curring解释为

    a ~> c
      <===>
    a -> () ~> c
    

    现在,如果我们洗礼 () ~> c 作为 IO c ,我们得到

    a ~> c
      <===>
    a -> IO c
    

    啊哈!这告诉我们,我们并不真正需要一般的不纯函数类型 a ~> c . 只要我们有它的特例 IO c = () ~> c ,我们可以表示(直到同构)任何 a~>c类 功能。

    从这里,人们可以开始在脑海中描绘出 输入输出电流 应该起作用,最终实现其一元结构。本质上,这种解释 输入输出电流 现在与上面给出的利用闭包的方法非常相似。

    推荐文章