在GHC中使用-S选项编译haskell源文件时,生成的汇编代码不清楚.汇编代码的哪些部分属于haskell代码的哪些部分之间没有明确的区别.与GCC不同,每个标签都根据其对应的功能命名.
GHC制作的这些名称是否有某种惯例？如何将生成的汇编代码中的某些部分与haskell代码中的相应部分相关联？
我正在玩State monad,我不知道在这段简单的代码中是什么导致了堆栈溢出.
import Control.Monad.State.Lazy
tick :: State Int Int
tick = do n <- get
put $! (n+1)
return n
million :: Int
million = snd $ runState (mapM_ (const tick) [1..1000000]) 0
main = print million
注意 我只想知道在这段代码中导致问题的原因,任务本身本身并不重要.
尾部调用是否在Frege中进行了优化.我知道在Java和编译为JVM字节码的语言中都没有TCO,如Clojure和Scala.弗雷格怎么样？
好的,所以我想到了带箭头的乐趣.我试图直接将性感的Haskell quicksort转换为使用箭头的实现.但它无法正常工作.
import Control.Arrow
qs :: Ord a => [a] -> [a]
qs = isEmpty >>> right (head &&& tail
>>> first ((qs.) . filter . (<)
&&& (\x -> (x:) . qs . filter (>=x)))
>>> first (uncurry (&&&))
>>> uncurry id
>>> uncurry (++))
>>> extract
where
isEmpty [] = Left []
isEmpty x = Right x
extract (Left x) = x
extract (Right x) = x
有人能发现问题吗？
我正在尝试处理一个非常大的unicode文本文件(6GB +).我想要的是计算每个独特单词的频率.Data.Map当我遍历文件时,我使用严格来跟踪每个单词的计数.这个过程需要太多时间和太多内存(20GB +).我怀疑地图很大,但我不确定它应该达到文件大小的5倍!代码如下所示.请注意我尝试了以下内容:
使用Data.HashMap.Strict而不是Data.Map.Strict.Data.Map似乎在较慢的内存消耗增加率方面表现更好.
使用lazy ByteString而不是lazy 读取文件Text.然后我编码为文本做一些处理,然后对其进行编码,回ByteString了IO.
import Data.Text.Lazy (Text(..), cons, pack, append)
import qualified Data.Text.Lazy as T
import qualified Data.Text.Lazy.IO as TI
import Data.Map.Strict hiding (foldr, map, foldl')
import System.Environment
import System.IO
import Data.Word
dictionate :: [Text] -> Map Text Word16
dictionate = fromListWith (+) . (`zip` [1,1..])
main = do
[file,out] <- getArgs
h <- openFile file ReadMode
hO <- openFile out WriteMode …这个小的haskell代码片段导致ghc在编译期间不终止:
{-# LANGUAGE BangPatterns #-}
{-# OPTIONS_GHC -O2 #-}
import qualified Data.Vector.Unboxed.Mutable as MV
import Data.Vector.Unboxed ((!))
import qualified Data.Vector.Unboxed as V
import Control.Monad (forM_)
similar :: V.Vector Char -> Int
similar v = l + sum (map (similar' 1 1) checks)
where
(l,checks) = let h = V.head v in V.foldl'
(\(i,is) c -> if c == h then (i+1,i:is) else (i+1,is)) (1,[]) (V.tail v)
similar' !r !n !i = if i < l-1 && v!(n) == …这个问题是关于Data.Vector包裹的.
鉴于一旦更新单元格,我将永远不会使用某个单元格的旧值.更新操作是否总是创建一个新的向量,反映更新,还是作为就地更新完成？
注意:我知道 Data.Vector.Mutable
我正在使用Data.Text.Lazy处理一些文本文件.我读了2个文件,并根据一些标准将文本分发到3个文件.执行处理的循环是go'.我已经设计了它应该以递增方式处理文件并且在内存中保持不变的方式.但是,一旦执行到达该go'部分,内存就会持续增加,直到最后达到大约90MB,从2MB开始.
有人可以解释为什么这种记忆增加发生以及如何避免它？
import qualified Data.Text.Lazy as T
import qualified Data.Text.Lazy.IO as TI
import System.IO
import System.Environment
import Control.Monad
main = do
[in_en, in_ar] <- getArgs
[h_en, h_ar] <- mapM (`openFile` ReadMode) [in_en, in_ar]
hSetEncoding h_en utf8
en_txt <- TI.hGetContents h_en
let len = length $ T.lines en_txt
len `seq` hClose h_en
h_en <- openFile in_en ReadMode
hs@[hO_lm, hO_en, hO_ar] <- mapM (`openFile` WriteMode) ["lm.txt", "tun_"++in_en, "tun_"++in_ar]
mapM_ (`hSetEncoding` utf8) [h_en, h_ar, hO_lm, hO_en, hO_ar] …