那些遇到过的问题

Haskell:实际的IO monad实现,用不同的语言？

KA1*_*KA1 15 io monads interpreter haskell

IO monad实际上是如何实现的？在意义上,该main函数的实际实现是什么？

我如何从另一种语言调用haskell函数(IO),在这种情况下,我是否需要维护IO自己？

是否main将IO操作(Lazily)作为引用拉出然后调用它们？或者它是解释工作,当它发现它可以调用它们的方式的行动？或者别的什么？

有不同语言的IO monad实现是否有助于深入理解主要功能中发生的事情？

编辑:

这hGetContents让我很困惑,让我不确定IO是如何真正实现的.

好吧,假设我有一个非常简单的纯Haskell解释器,不幸的是没有IO支持,并且为了好奇,我想向它添加这个IO动作(unsafeIO技巧也).很难从GHC,Hugs或其他人那里得到它.

Rot*_*sor 25

以下是如何在Java中实现IO monad的示例:

package so.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import static so.io.IOMonad.*;  
import static so.io.ConsoleIO.*;    

/**
 * This is a type containing no data -- corresponds to () in Haskell.
 */
class Unit {
    public final static Unit VALUE = new Unit(); 
}

/**
 * This type represents a function from A to R
 */
interface Function<A,R> {
    public R apply(A argument);
}

/**
 * This type represents an action, yielding type R
 */
interface IO<R> {
    /**
     * Warning! May have arbitrary side-effects!
     */
    R unsafePerformIO();
}

/**
 * This class, internally impure, provides pure interface for action sequencing (aka Monad)
 */
class IOMonad {
    static <T> IO<T> pure(final T value) {
        return new IO<T>() {
            @Override
            public T unsafePerformIO() {
                return value;
            }
        };
    }

    static <T> IO<T> join(final IO<IO<T>> action) {
        return new IO<T>(){
            @Override
            public T unsafePerformIO() {
                return action.unsafePerformIO().unsafePerformIO();
            }
        };
    }

    static <A,B> IO<B> fmap(final Function<A,B> func, final IO<A> action) {
        return new IO<B>(){
            @Override
            public B unsafePerformIO() {
                return func.apply(action.unsafePerformIO());
            }
        };
    }

    static <A,B> IO<B> bind(IO<A> action, Function<A, IO<B>> func) {
        return join(fmap(func, action));
    }
}

/**
 * This class, internally impure, provides pure interface for interaction with stdin and stdout
 */
class ConsoleIO {
    static IO<Unit> putStrLn(final String line) {
        return new IO<Unit>() {
            @Override
            public Unit unsafePerformIO() {
                System.out.println(line);
                return Unit.VALUE;
            }
        };
    };

    // Java does not have first-class functions, thus this:
    final static Function<String, IO<Unit>> putStrLn = new Function<String, IO<Unit>>() {
        @Override
        public IO<Unit> apply(String argument) {
            return putStrLn(argument);
        }
    };

    final static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    static IO<String> getLine = new IO<String>() {
            @Override
            public String unsafePerformIO() {
                try {
                    return in.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        };
}

/**
 * The program composed out of IO actions in a purely functional manner.
 */
class Main {

    /**
     * A variant of bind, which discards the bound value.
     */
    static IO<Unit> bind_(final IO<Unit> a, final IO<Unit> b) {
        return bind(a, new Function<Unit, IO<Unit>>(){
            @Override
            public IO<Unit> apply(Unit argument) {
                return b;
            }
        });
    }

    /**
     * The greeting action -- asks the user for his name and then prints a greeting
     */
    final static IO<Unit> greet = 
            bind_(putStrLn("Enter your name:"), 
            bind(getLine, new Function<String, IO<Unit>>(){
                @Override
                public IO<Unit> apply(String argument) {
                    return putStrLn("Hello, " + argument + "!");
                }
            }));

    /**
     * A simple echo action -- reads a line, prints it back
     */
    final static IO<Unit> echo = bind(getLine, putStrLn);

    /**
     * A function taking some action and producing the same action run repeatedly forever (modulo stack overflow :D)
     */
    static IO<Unit> loop(final IO<Unit> action) {
        return bind(action, new Function<Unit, IO<Unit>>(){
            @Override
            public IO<Unit> apply(Unit argument) {
                return loop(action);
            }
        });
    }

    /**
     * The action corresponding to the whole program
     */
    final static IO<Unit> main = bind_(greet, bind_(putStrLn("Entering the echo loop."),loop(echo)));
}

/**
 * The runtime system, doing impure stuff to actually run our program.
 */
public class RTS {
    public static void main(String[] args) {
        Main.main.unsafePerformIO();
    }
}
Run Code Online (Sandbox Code Playgroud)

这是一个运行时系统,它实现了控制台I/O的接口,以及一个小的纯功能程序,它向用户打招呼,然后运行一个echo循环.

人们无法在Haskell中实现不安全的部分,因为Haskell是纯粹的函数式语言.它始终使用较低级别的设施实施.

Mar*_*sey 8

使用Java 8 Lambdas,您可以从Rotsor上面的答案中获取代码,删除Function类,因为Java 8提供了一个与FunctionalInterface相同的功能,并删除匿名类cruft以实现更清晰的代码,如下所示:

package so.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.function.Function;

import static so.io.IOMonad.*;
import static so.io.ConsoleIO.*;

/**
 * This is a type containing no data -- corresponds to () in Haskell.
 */
class Unit {

   // -- Unit$

   public final static Unit VALUE = new Unit();

   private Unit() {
   }

}

/** This type represents an action, yielding type R */
@FunctionalInterface
interface IO<R> {

   /** Warning! May have arbitrary side-effects! */
   R unsafePerformIO();

}

/**
 * This, internally impure, provides pure interface for action sequencing (aka
 * Monad)
 */
interface IOMonad {

   // -- IOMonad$

   static <T> IO<T> pure(final T value) {
      return () -> value;
   }

   static <T> IO<T> join(final IO<IO<T>> action) {
      return () -> action.unsafePerformIO().unsafePerformIO();
   }

   static <A, B> IO<B> fmap(final Function<A, B> func, final IO<A> action) {
      return () -> func.apply(action.unsafePerformIO());
   }

   static <A, B> IO<B> bind(IO<A> action, Function<A, IO<B>> func) {
      return join(fmap(func, action));
   }

}

/**
 * This, internally impure, provides pure interface for interaction with stdin
 * and stdout
 */
interface ConsoleIO {

   // -- ConsoleIO$

   static IO<Unit> putStrLn(final String line) {
      return () -> {
         System.out.println(line);
         return Unit.VALUE;
      };
   };

   final static Function<String, IO<Unit>> putStrLn = arg -> putStrLn(arg);

   final static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

   static IO<String> getLine = () -> {
      try {
         return in.readLine();
      }

      catch (IOException e) {
         throw new RuntimeException(e);
      }
   };

}

/** The program composed out of IO actions in a purely functional manner. */
interface Main {

   // -- Main$

   /** A variant of bind, which discards the bound value. */
   static IO<Unit> bind_(final IO<Unit> a, final IO<Unit> b) {
      return bind(a, arg -> b);
   }

   /**
    * The greeting action -- asks the user for his name and then prints 
    * greeting
    */
   final static IO<Unit> greet = bind_(putStrLn("Enter your name:"),
         bind(getLine, arg -> putStrLn("Hello, " + arg + "!")));

   /** A simple echo action -- reads a line, prints it back */
   final static IO<Unit> echo = bind(getLine, putStrLn);

   /**
    * A function taking some action and producing the same action run repeatedly
    * forever (modulo stack overflow :D)
    */
   static IO<Unit> loop(final IO<Unit> action) {
      return bind(action, arg -> loop(action));
   }

    /** The action corresponding to the whole program */
    final static IO<Unit> main = bind_(greet, bind_(putStrLn("Entering the echo loop."), loop(echo)));

}

/** The runtime system, doing impure stuff to actually run our program. */
public interface RTS {

    // -- RTS$

    public static void main(String[] args) {
       Main.main.unsafePerformIO();
    }

 }
Run Code Online (Sandbox Code Playgroud)

请注意,我还将类声明的静态方法更改为接口声明的静态方法.为什么？没有特别的原因,只是你可以在Java 8中.

  • 谢谢,lambdas确实让它看起来更好!怎么了那些看似毫无意义的评论,比如`// - Unit $`虽然如此？它们对我来说看起来不像javadoc.什么解释他们？ (2认同)

Nor*_*sey 7

如果你想了解IO monad的实现,那么在Phil Wadler和Simon Peyton Jones的获奖论文中对它进行了很好的描述,他们想出了如何使用monads以纯语言进行输入/输出. .该论文是命令式功能编程,在两个作者的网站上.

ntc*_*tc2 6

以下是IOGHC 7.10 中的实际实现。

的IO，实质上是在类型的状态单子State# RealWorld（在定义的GHC.Types）：

{- |
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 #))
Run Code Online (Sandbox Code Playgroud)

该IO单子是严格的，因为bindIO由定义case匹配（在定义的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
Run Code Online (Sandbox Code Playgroud)

此实现在Edward Yang 的博客文章中进行了讨论。

fuz*_*fuz 5

该IO单子基本上实施为状态变压器(类似State),用专用的令牌RealWorld.每个IO操作都依赖于此令牌,并在完成时传递它.unsafeInterleaveIO引入了第二个令牌,以便可以启动新的IO操作,而另一个仍在执行其工作.

通常,您不必关心实施.如果要从其他语言调用IO函数,GHC会关心删除IO包装器.考虑一下这个小片段:

printInt :: Int -> IO ()
printInt int = do putStr "The argument is: "
                  print int

foreign export ccall printInt :: Int -> IO ()
Run Code Online (Sandbox Code Playgroud)

这将生成一个printInt从C 调用的符号.该函数变为:

extern void printInt(HsInt a1);
Run Code Online (Sandbox Code Playgroud)

哪里HsInt只是一个(取决于你的平台)typedefd int.所以你看,monad IO已被完全删除.

归档时间：

查看次数：

3938 次

最近记录：

10 年，1 月 前
相关归档
Erlang"单一赋值"与Haskell"不可变值"不同吗？ 15
Haskell中的Functor设计模式 10
为什么`cat <(cat)`会产生EIO？ 10
为什么GHC有时会拒绝懒惰？ 8
Haskell中的部分导数 7
Java,从txt文件中读取的最快的类 6
弗雷格如何概括数字文字？ 6
Haskell元组monad是否太严格？ 5
在字符串上运行sed,在"<<<"上使用"echo"+"pipe"的好处 3
在monad的上下文中一定要使用符号吗？ 1
难疑归档
如何让Git"忘记"一个被跟踪但现在位于.gitignore的文件？ 4888
如何迭代字符串的单词？ 2895
HTML中id属性的有效值是什么？ 1945
使div填充剩余屏幕空间的高度 1743
Bower和npm有什么区别？ 1723
Java内部类和静态嵌套类 1691
Java是否支持默认参数值？ 1569
确定整数平方根是否为整数的最快方法 1403
在C#中调用基础构造函数 1398
同步检查Node.js中是否存在文件/目录 1113