标签: ghc

一个简单的计划:

import qualified Data.ByteString.Lazy.Char8 as BS

main = do
  wc <- length . BS.words <$> BS.getContents
  print wc

为速度而建:

ghc -fllvm -O2 -threaded -rtsopts Words.hs

更多的CPU意味着更慢？

$ time ./Words +RTS -qa -N1 < big.txt
331041862

real  0m25.963s
user  0m21.747s
sys 0m1.528s
$ time ./Words +RTS -qa -N2 < big.txt
331041862

real  0m36.410s
user  0m34.910s
sys 0m6.892s
$ time ./Words +RTS -qa -N4 < big.txt
331041862

real  0m42.150s
user  0m55.393s
sys 0m16.227s

好的措施:

$time wc -w big.txt
 331041862 big.txt

real    0m8.277s …

我为Core Haskell编写了一个定制漂亮的打印机,以便更好地研究Core的结构.这个漂亮的打印机的要点是它需要一个CoreModule并在输出中包含数据构造函数,默认Outputable实现似乎没有.

这是我运行漂亮的打印机的模块的代码:

module Bar2 where

add :: Int -> Int -> Int
add a b = a + b

add2 a b = a + b

这是漂亮的打印机输出:

------------------------------- Module Metadata --------------------------------
Module { "main" :: modulePackageId, "Bar2" :: moduleName }
-------------------------------- Type Bindings ---------------------------------
[r0 :-> Identifier ‘add’, rjH :-> Identifier ‘add2’]
-------------------------------- Core Bindings ---------------------------------
NonRec (Id "add2")
       (Lam (TyVar "a")
            (Lam (Id "$dNum")
                 (Lam (Id "a1")
                      (Lam (Id "b")
                           (App (App (App (App …

我写了一个Eratosthenes程序的筛子,ST.Strict当我看到它占用了大量的内存时,我正在剖析它:

Sun Jul 10 18:27 2016 Time and Allocation Profiling Report  (Final)

   Primes +RTS -hc -p -K1000M -RTS 10000000

total time  =        2.32 secs   (2317 ticks @ 1000 us, 1 processor)
total alloc = 5,128,702,952 bytes  (excludes profiling overheads)

(其中10 ^ 7)是我要求它生成的素数.

奇怪的是,分析图表显示了完全不同的东西:

我在其中一张图中误读了什么吗？或者这些工具之一有什么问题吗？

作为参考,我的代码是

{-# LANGUAGE BangPatterns #-}

import Prelude hiding (replicate, read)
import qualified Text.Read as T
import Data.Vector.Unboxed.Mutable(replicate, write, read)
import Control.Monad.ST.Strict
import Data.STRef
import Control.Monad.Primitive

import Control.Monad

import System.Environment

main = print . length …

我试图以列表形式(例如[3,2,1]为3x ^ 2 + 2x + 1)进行多项式表示,并通过对多项式执行apply和x的数字来对其进行求值.将对x进行多项式求值.

这是我的代码:

newtype Poly a = P [a]

apply :: Num a => Poly a -> Num a -> Num a
apply (P p) x = if (i > 0) then (x * ((head p) ^ i)) + (apply (P (tail p)) x) else p
    where  i = length p

问题是当我尝试编译此代码时,我收到一个我不理解的错误:

期望一个类型,但'Num a'有类'GHC.Prim.Constraint'
在'apply' 的类型签名中:
apply :: Num a => Poly a - > Num a - > Num a

运行Haskell程序时,+ RTS -s报告诸如"字节最大驻留时间"之类的信息.有没有办法从Haskell程序中访问这些信息？Hackage上有一个提供此功能的库吗？

如果没有,有没有办法访问当前使用的内存量？例如,终端命令"top"显示的数量？

我正在尝试编写以下函数:

memcpyByteArrayToPtr :: 
     ByteArray# -- ^ source
  -> Int -- ^ start
  -> Int -- ^ length
  -> Ptr a -- ^ destination
  -> IO ()

行为应该在内部用于memcpy将a的内容复制ByteArray#到Ptr.我有两种技术可以做这样的事情,但我很难推断他们的安全.

第一个是在内存包中找到的.有一个辅助函数withPtr定义为:

data Bytes = Bytes (MutableByteArray# RealWorld)

withPtr :: Bytes -> (Ptr p -> IO a) -> IO a
withPtr b@(Bytes mba) f = do
    a <- f (Ptr (byteArrayContents# (unsafeCoerce# mba)))
    touchBytes b
    return a

但是,我很确定这只是安全的,因为构建的唯一方法Bytes是使用一个调用的智能构造函数newAlignedPinnedByteArray#.给出类似问题和 …

作为家庭作业的一部分,我正在尝试做一些非常简单的事情.我需要做的就是编写一个函数,该函数接收表示三角形的基本长度和高度长度的2元组数字列表,并返回与这些三角形对应的区域列表.其中一个要求是我通过定义一个函数并在where子句中声明其类型来实现这一点.到目前为止我尝试的所有东西都无法编译,这就是我所拥有的:

calcTriangleAreas xs = [triArea x | x<-xs]
    where triArea:: (Num, Num) -> Num --this uses 4 preceding spaces 
triArea (base, height) = base*height/2

这失败了The type signature for ‘triArea’ lacks an accompanying binding,这对我来说听起来像triArea没有在where子句中定义.好吧,让我们缩进它以匹配where:

calcTriangleAreas xs = [triArea x | x<-xs]
    where triArea:: (Num, Num) -> Num --this uses 4 preceding spaces 
    triArea (base, height) = base*height/2 --... and so does this

这个无法编译特别无法提供的错误消息parse error on input triArea.只是为了好玩,让我们再尝试缩进它,因为idk还有什么可做的:

calcTriangleAreas xs = [triArea x | …

这是我正在尝试编写代码的一个简化的,也许是愚蠢的例子(这更复杂,涉及列表长度的编译时编码).

鉴于以下内容:

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GADTs #-}

data D (a :: Bool) where
  D :: Bool -> D a

我想要以下功能g:

g :: D a -> Bool
g (D x) = x == a

当然,这不会编译为a类型,而不是值.

这是一个可能的解决方案:

class C (a :: Bool) where
  f :: D a -> Bool

instance C True where
  f (D x) = x == True

instance C False where
  f (D x) = x == False …

这个最近的问题让我想到了Haskell使用无限列表的能力.有大量 的 其他问题,并约在计算器上无限列表答案,我明白了为什么我们不能对所有无限列表的通用解决方案,但为什么不能哈斯克尔推理一些无限列表？

让我们使用第一个链接问题中的示例:

list1 = [1..]
list2 = [x | x <- list1, x <= 4]
print list2
$ [1,2,3,4

@ user2297560在评论中写道:

假装你是GHCI.您的用户会为您提供无限列表,并要求您查找该列表中小于或等于4的所有值.您将如何进行此操作？(请记住,您不知道列表是否有序.)

在这种情况下,用户没有给你一个无限的列表.GHC产生了它!实际上,它是按照自己的规则生成的.该哈斯克尔2010标准规定如下:

enumFrom       :: a -> [a]            -- [n..]  

对于Int和Integer类型,枚举函数具有以下含义:

• 序列enumFrom e1是列表[ e1,e1+ 1,e1+ 2,...].

在他对另一个问题的回答中,@ chepner写道:

你知道列表是单调递增的,但Haskell没有.

这些用户所做的陈述似乎与我的标准不符.Haskell使用单调增加以有序的方式创建了列表.Haskell 应该知道列表是有序的和单调的.那么为什么不能将这个无限列表自动[x | x <- list1, x <= 4]转化takeWhile (<= 4) list1呢？

我最近在Haskell遇到了这个奇怪的问题.下面的代码应该返回一个修剪到一个范围的值(如果它在high它之上它应该返回,high如果它在low它下面应该返回low.

inRange :: Int -> Int -> Int -> Int
inRange low high = max low $ min high

错误消息是:

scratch.hs:2:20:
    Couldn't match expected type ‘Int -> Int’ with actual type ‘Int’
    In the expression: max low $ min high
    In an equation for ‘inRange’: inRange low high = max low $ min high

scratch.hs:2:30:
    Couldn't match expected type ‘Int’ with actual type ‘Int -> Int’
    Probable cause: ‘min’ is applied to …