blocks|key|348860|text|如果你真的很关心速度，你会因为每次启动都要重新解析代码而受到阻碍。Haskell不需要从解释器运行，用GHC编译它，你应该会得到很好的性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|348861|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/ghc/^0|1F|3|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If you are really concerned with speed you are going to be hampered by re-parsing the code for every launch. Haskell doesn't need to be run from an interpreter, compile it with <a href="http://www.haskell.org/ghc/" rel="nofollow noreferrer">GHC</a> and you should get excellent performance.

blocks|key|343979|text|这个问题有两个部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|343980|你关心performance|343981|you想要的脚本|unordered-list-item|343982|343983|343984|343985|如果您关心性能，那么唯一重要的选择是GHC，它非常非常快：http://shootout.alioth.debian.org/u64q/benchmark.php?test=all&lang=all|offset|length|343986|如果你想要一些轻量级的Unix脚本，我会使用GHCi。它比Hugs快30倍左右，但也支持hackage上的所有库。|343987|所以现在就安装GHC+(免费获取GHCi+)。|343988|entityMap|0|LINK|mutability|MUTABLE|url|http://shootout.alioth.debian.org/u64q/benchmark.php?test=all&lang=all^0|0|0|0|0|0|0|T|1Y|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|12|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@$L|16|M|17|1|18]]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1A|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

You have two parts to this question:

<ul>
<li>you care about performance</li>
<li>you want scripting</li>
</ul>

If you care about performance, the only serious option is GHC, which is very very fast: <a href="http://shootout.alioth.debian.org/u64q/benchmark.php?test=all&amp;lang=all" rel="nofollow noreferrer">http://shootout.alioth.debian.org/u64q/benchmark.php?test=all&amp;lang=all</a>

If you want something light for Unix scripting, I'd use GHCi. It is about 30x faster than Hugs, but also supports all the libraries on hackage.

So install GHC now (and get GHCi for free).

blocks|key|346252|text|使用ghc+-e相当于调用ghci。我相信GHC的runhaskell在运行它之前会将代码编译成临时可执行文件，而不是像ghc+-e/ghci那样解释它，但我不是100%25确定。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|346253|$+time+echo+'Hello,+world!'
Hello,+world!

real++++0m0.021s
user++++0m0.000s
sys+++++0m0.000s
$+time+ghc+-e+'putStrLn+"Hello,+world!"'
Hello,+world!

real++++0m0.401s
user++++0m0.031s
sys+++++0m0.015s
$+echo+'main+=+putStrLn+"Hello,+world!"'+>+hw.hs
$+time+runhaskell+hw.hs
Hello,+world!

real++++0m0.335s
user++++0m0.015s
sys+++++0m0.015s
$+time+ghc+--make+hw
[1+of+1]+Compiling+Main+++++++++++++(+hw.hs,+hw.o+)
Linking+hw+...

real++++0m0.855s
user++++0m0.015s
sys+++++0m0.015s
$+time+./hw
Hello,+world!

real++++0m0.037s
user++++0m0.015s
sys+++++0m0.000s|code-block|syntax|javascript|346254|在运行之前简单地编译所有的“脚本”有多难？|346255|编辑|346256|啊，为多个架构提供二进制文件确实是一件痛苦的事情。我以前也走过这条路，但这并不好玩...|346257|遗憾的是，我认为不可能让任何Haskell编译器的启动开销变得更好。这种语言的声明性质意味着，即使在尝试输入检查任何东西之前，也有必要先阅读整个程序，更不用说执行了，然后你要么承受严格分析的代价，要么承受不必要的懒惰和笨拙。|346258|流行的“脚本”语言(shell、Perl、Python等)基于ML的语言只需要一次遍历...好吧，ML需要一个静态的类型检查遍，而Perl有这个有趣的5遍方案(其中两个是反向运行的)；无论哪种方式，过程化意味着编译器/解释器将程序片段组装在一起的工作要容易得多。|346259|简而言之，我认为不可能有比这更好的了。我还没有测试过Hugs或GHCi是否有更快的启动速度，但它们与非Haskell语言的区别仍然很大。|346260|entityMap^0|2|6|D|4|P|A|1O|6|1V|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1C|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1F|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|X|$]]

Using <code>ghc -e</code> is pretty much equivalent to invoking <code>ghci</code>. I believe that GHC's <code>runhaskell</code> compiles the code to a temporary executable before running it, as opposed to interpreting it like <code>ghc -e</code>/<code>ghci</code>, but I'm not 100% certain.

<pre><code>$ time echo 'Hello, world!'
Hello, world!

real 0m0.021s
user 0m0.000s
sys 0m0.000s
$ time ghc -e 'putStrLn "Hello, world!"'
Hello, world!

real 0m0.401s
user 0m0.031s
sys 0m0.015s
$ echo 'main = putStrLn "Hello, world!"' &gt; hw.hs
$ time runhaskell hw.hs
Hello, world!

real 0m0.335s
user 0m0.015s
sys 0m0.015s
$ time ghc --make hw
[1 of 1] Compiling Main ( hw.hs, hw.o )
Linking hw ...

real 0m0.855s
user 0m0.015s
sys 0m0.015s
$ time ./hw
Hello, world!

real 0m0.037s
user 0m0.015s
sys 0m0.000s
</code></pre>

How hard is it to simply compile all your "scripts" before running them?

<h3>Edit</h3>

Ah, providing binaries for multiple architectures is a pain indeed. I've gone down that road before, and it's not much fun...

Sadly, I don't think it's possible to make any Haskell compiler's startup overhead any better. The language's declarative nature means that it's necessary to read the entire program first even before trying to typecheck anything, nevermind execution, and then you either suffer the cost of strictness analysis or unnecessary laziness and thunking.

The popular 'scripting' languages (shell, Perl, Python, etc.) and the ML-based languages require only a single pass... well okay, ML requires a static typecheck pass and Perl has this amusing 5-pass scheme (with two of them running in reverse); either way, being procedural means that the compiler/interpreter has a lot easier of a job assembling the bits of the program together.

In short, I don't think it's possible to get much better than this. I haven't tested to see if Hugs or GHCi has a faster startup, but any difference there is still faaar away from non-Haskell languages.

blocks|key|346348|text|为什么不创建一个脚本前端来编译脚本，如果它以前没有过，或者如果编译的版本是过时的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|346349|这是基本的想法，这段代码可以改进很多--搜索路径而不是假设所有东西都在同一个目录中，更好地处理其他文件扩展名，等等。另外，我对haskell编码(ghc-+green+script.hs)很陌生：|346350|import+Control.Monad
import+System
import+System.Directory
import+System.IO
import+System.Posix.Files
import+System.Posix.Process
import+System.Process

getMTime+f+=+getFileStatus+f+>>=+return+.+modificationTime

main+=+do
++scr+:+args+<-+getArgs
++let+cscr+=+takeWhile+(/=+'.')+scr

++scrExists+<-+doesFileExist+scr
++cscrExists+<-+doesFileExist+cscr
++compile+<-+if+scrExists+&&+cscrExists
+++++++++++++++then+do
+++++++++++++++++scrMTime+<-+getMTime+scr
+++++++++++++++++cscrMTime+<-+getMTime+cscr
+++++++++++++++++return+$+cscrMTime+<=+scrMTime
+++++++++++++++else
+++++++++++++++++++return+True

++when+compile+$+do
+++++++++r+<-+system+$+"ghc+--make+"+%2B%2B+scr
+++++++++case+r+of
+++++++++++ExitFailure+i+->+do
+++++++++++++++++++hPutStrLn+stderr+$
++++++++++++++++++++++++++++"'ghc+--make+"+%2B%2B+scr+%2B%2B+"'+failed:+"+%2B%2B+show+i
+++++++++++++++++++exitFailure
+++++++++++ExitSuccess+->+return+()

++executeFile+cscr+False+args+Nothing|code-block|syntax|javascript|346351|现在我们可以创建这样的脚本(hs-+such+.hs)：|346352|#!+ghc-compiled-script

import+Data.List
import+System
import+System.Environment

main+=+do
++args+<-+getArgs
++putStrLn+$+foldl+(%2B%2B)+""+$+intersperse+"+"+args|346353|现在运行它：|346354|$+time+hs-echo.hs+"Hello,+world\!"+++++
[1+of+1]+Compiling+Main+++++++++++++(+hs-echo.hs,+hs-echo.o+)
Linking+hs-echo+...
Hello,+world!
hs-echo.hs+"Hello,+world!"++0.83s+user+0.21s+system+97%25+cpu+1.062+total

$+time+hs-echo.hs+"Hello,+world,+again\!"
Hello,+world,+again!
hs-echo.hs+"Hello,+world,+again!"++0.01s+user+0.00s+system+60%25+cpu+0.022+total|346355|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Why not create a script front-end that compiles the script if it hasn't been before or if the compiled version is out of date.

Here's the basic idea, this code could be improved a lot--search the path rather then assuming everything's in the same directory, handle other file extensions better, etc. Also i'm pretty green at haskell coding (ghc-compiled-script.hs):

<pre><code>import Control.Monad
import System
import System.Directory
import System.IO
import System.Posix.Files
import System.Posix.Process
import System.Process

getMTime f = getFileStatus f &gt;&gt;= return . modificationTime

main = do
 scr : args &lt;- getArgs
 let cscr = takeWhile (/= '.') scr

 scrExists &lt;- doesFileExist scr
 cscrExists &lt;- doesFileExist cscr
 compile &lt;- if scrExists &amp;&amp; cscrExists
 then do
 scrMTime &lt;- getMTime scr
 cscrMTime &lt;- getMTime cscr
 return $ cscrMTime &lt;= scrMTime
 else
 return True

 when compile $ do
 r &lt;- system $ "ghc --make " ++ scr
 case r of
 ExitFailure i -&gt; do
 hPutStrLn stderr $
 "'ghc --make " ++ scr ++ "' failed: " ++ show i
 exitFailure
 ExitSuccess -&gt; return ()

 executeFile cscr False args Nothing
</code></pre>

Now we can create scripts such as this (hs-echo.hs):

<pre><code>#! ghc-compiled-script

import Data.List
import System
import System.Environment

main = do
 args &lt;- getArgs
 putStrLn $ foldl (++) "" $ intersperse " " args
</code></pre>

And now running it:

<pre><code>$ time hs-echo.hs "Hello, world\!" 
[1 of 1] Compiling Main ( hs-echo.hs, hs-echo.o )
Linking hs-echo ...
Hello, world!
hs-echo.hs "Hello, world!" 0.83s user 0.21s system 97% cpu 1.062 total

$ time hs-echo.hs "Hello, world, again\!"
Hello, world, again!
hs-echo.hs "Hello, world, again!" 0.01s user 0.00s system 60% cpu 0.022 total
</code></pre>

blocks|key|346382|text|让一个ghci守护进程和一个feeder脚本获取脚本路径和位置，与已经运行的ghci进程通信，在正确的目录中加载和执行脚本，并通过管道将输出返回到stdout的feeder脚本，这样会怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|346383|不幸的是，我不知道如何编写这样的东西，但从ghci中的:l的速度来看，它似乎真的很快。看起来runhaskell的大部分开销都花在了启动ghci上，而不是解析和运行脚本。|346384|编辑：经过一番尝试后，我发现Hint+package+(+GHC的包装器)在这里非常有用。下面的代码将加载传入的模块名称(这里假设它在同一目录中)，并将执行main函数。现在剩下的“全部”就是让它成为守护进程，并让它接受管道或套接字上的脚本。|offset|length|style|BOLD|346385|import+Language.Haskell.Interpreter
import+Control.Monad

run+=+runInterpreter+.+test

test+::+String+->+Interpreter+()
test+mname+=+
++do
++++loadModules+[mname+%2B%2B+".hs"]
++++setTopLevelModules+[mname]
++++res+<-+interpret+"main"+(as+::+IO())
++++liftIO+res|code-block|syntax|javascript|346386|Edit2:就stdout/err/in而言，使用this+specific+GHC+trick似乎可以将客户机程序的std重定向到feeder程序，然后重定向到守护进程一直连接的一些命名管道(可能)，然后将守护进程的stdout重定向到feeder程序正在侦听的另一个命名管道。伪示例：|346387|grep+...+%7C+feeder+my_script.hs+%7C+xargs+...
++++++++++++%7C+++%5E----------------+<
++++++++++++V++++++++++++++++++++++%7C
+++++++++named+pipe+->+daemon+->+named+pipe|346388|在这里，feeder是一个小的编译的工具程序，它只需将std重定向到守护进程中，然后再重定向出守护进程，并将脚本的名称和位置提供给守护进程。|346389|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/hint|1|http://nominolo.blogspot.com/2010/04/haskell-tip-redirect-stdout-in-haskell.html^0|0|0|0|3|E|C|0|0|0|0|6|P|N|1|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@$F|17|G|18|H|I]]|9|@$F|19|G|1A|1|1B]]|A|$]]|$1|J|3|K|5|L|7|1C|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1D|8|@$F|1E|G|1F|H|I]]|9|@$F|1G|G|1H|1|1I]]|A|$]]|$1|Q|3|R|5|L|7|1J|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]]]

What about having a ghci daemon and a feeder script that takes the script path and location, communicates with the already running ghci process to load and execute the script in the proper directory and pipes the output back to the feeder script for stdout?

Unfortunately, I have no idea how to write something like this, but it seems like it could be really fast judging by the speed of :l in ghci. As it seems most of the cost in runhaskell is in starting up ghci, not parsing and running the script. 

Edit: After some playing around, I found the <a href="http://hackage.haskell.org/package/hint" rel="nofollow">Hint package</a> (a wrapper around the GHC API) to be of perfect use here. The following code will load the passed in module name (here assumed to be in the same directory) and will execute the main function. Now 'all' that's left is to make it a daemon, and have it accept scripts on a pipe or socket.

<pre><code>import Language.Haskell.Interpreter
import Control.Monad

run = runInterpreter . test

test :: String -&gt; Interpreter ()
test mname = 
 do
 loadModules [mname ++ ".hs"]
 setTopLevelModules [mname]
 res &lt;- interpret "main" (as :: IO())
 liftIO res
</code></pre>

Edit2: As far as stdout/err/in go, using <a href="http://nominolo.blogspot.com/2010/04/haskell-tip-redirect-stdout-in-haskell.html" rel="nofollow">this specific GHC trick</a> It looks like it would be possible to redirect the std's of the client program into the feeder program, then into some named pipes (perhaps) that the daemon is connected to at all times, and then have the daemon's stdout back to another named pipe that the feeder program is listening to. Pseudo-example:

<pre><code>grep ... | feeder my_script.hs | xargs ...
 | ^---------------- &lt;
 V |
 named pipe -&gt; daemon -&gt; named pipe
</code></pre>

Here the feeder would be a small compiled harness program to just redirect the std's into and then back out of the daemon and give the name and location of the script to the daemon.

Does anyone know of a quick-starting Haskell interpreter that would be suitable for use in writing shell scripts? Running 'hello world' using Hugs took 400ms on my old laptop and takes 300ms on my current Thinkpad X300. That's too slow for instantaneous response. Times with GHCi are similar.

Functional languages don't have to be slow: both Objective Caml and Moscow ML run hello world in 1ms or less.

Clarification: I am a heavy user of GHC and I know how to use GHCi. I know all about compiling to get things fast. Parsing costs should be completely irrelevant: if ML and OCaml can start 300x faster than GHCi, then there is room for improvement.

I am looking for

<ul>
<li>The convenience of scripting: one source file, no binary code, same code runs on all platforms</li>
<li>Performance comparable to other interpreters, including fast startup and execution for a simple program like

<pre><code>module Main where
main = print 33
</code></pre></li>
</ul>

I am not looking for compiled performance for more serious programs. The whole point is to see if Haskell can be useful for scripting.

Is there a quick-starting Haskell interpreter suitable for scripting?

编译器

解释器

Python

Unix

Perl

有没有人知道一个快速入门的Haskell解释器，可以用来编写shell脚本？在我的旧笔记本电脑上用Hugs运行“hello world”需要400毫秒，在我现在的Thinkpad X300上需要300毫秒。这对于即时响应来说太慢了。使用GHCi的时间是相似的。函数式语言不必很慢: Objective Caml和莫斯科M...

问有没有适合编写脚本的快速入门的Haskell解释器？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有适合编写脚本的快速入门的Haskell解释器？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有适合编写脚本的快速入门的Haskell解释器？
EN