小编gat*_*ado的帖子

我没有正式的延续知识,我想知道是否有人可以帮助我验证和理解我写的代码:).

问题

我试图解决的一般问题是转换表达式

(2 * var) + (3 * var) == 4

进入功能

\x y -> 2 * x + 3 * y == 4 -- (result)

然后可以将其传递到yices-painless包中.

动机

作为一个更简单的例子,请注意将var其翻译成\x -> x.我们怎样才能乘两个var的(表示他们\x -> x和\y -> y)到一个表达\x -> \y -> x * y？

我听说延续被描述为"计算的其余部分",并认为这就是我所需要的.遵循这个想法,var应该采取一种功能

f :: ? -> E -- rest of computation

其参数将是创建的变量的值var,并返回我们想要的内容(代码列表标记result),一个新函数接受变量x并返回f x.因此,我们定义,

var' …

我刚刚开始阅读有关类别理论的内容,如果有人能够解释CS逆变/协方差和类别理论之间的联系,我将非常感激.一些示例类别会是什么(即它们的对象/态射是什么？)？提前致谢？

我想在Haskell中编写一个尽可能高效的并行映射函数.我最初的尝试,似乎是目前最好的,只是写,

pmap :: (a -> b) -> [a] -> [b]
pmap f = runEval . parList rseq . map f

但是,我没有看到完美的CPU划分.如果这可能与火花的数量有关,我可以编写一个将列表划分为#ppus段的pmap ,因此创建了最少的火花吗？我试过以下,但是性能(和火花的数量)要差得多,

pmap :: (a -> b) -> [a] -> [b]
pmap f xs = concat $ runEval $ parList rseq $ map (map f) (chunk xs) where
    -- the (len / 4) argument represents the size of the sublists
    chunk xs = chunk' ((length xs) `div` 4) xs
    chunk' n xs | length xs <= n = …

我正在寻找像show这样的函数,它可以产生更多可读输出.它当然不必在所有课程上工作.我在Google上搜索过"haskell pretty print",但这似乎产生了编译器源代码打印机.调试以下内容(为stackoverflow格式化手动插入换行符)很难!

(fromList [(Ref {name = "phi", lenRef = 4},fromList [CompNode {val = 1, ident = CNId {uid =     4,
 zone = 0}, deps = []},CompNode {val = 2, ident = CNId {uid = 5, zone = 0}, deps = []},CompNode 
{val = 3, ident = CNId {uid = 6, zone = 0}, deps = []},CompNode {val = 4, ident = CNId {uid = 7, 
zone = 0}, deps = []}] :: Data.Vector.Vector),(Ref {name = "phi'", lenRef = 2},fromList …

这是一个愚蠢的问题,一直困扰着我.为什么我不能写一个包含多个参数的newtype,

newtype A = A Int Int

虽然元组版本很好吗？

newtype A = A (Int, Int)

前者在模式匹配等方面要好得多.

我想在本地使用Hoogle,因此我可以在我的某个项目上运行搜索查询.[有一些文档这里 ],但我无法弄清楚如何得到它的工作.它说运行Haddock,但是haddock没有提供任何输出,只是吐出下面复制的警告.我还没有projectname.cabal文件,所以我无法使用该runhaskell Setup haddock --hoogle命令.

haddock coverage for ./Util.hs:     0/8   0%
haddock coverage for ./Blockify.hs:    0/16   0%
haddock coverage for ./Interpreter.hs:     0/9   0%
haddock coverage for AbstractSummarizer.hs:    0/10   0%
Warning: Util: could not find link destinations for:
    GHC.Base.String GHC.Types.IO GHC.ST.ST Data.StateRef.Types.HasRef GHC.Base.Monad Control.Applicative.Applicative GHC.Types.Int Control.Monad.Trans.State.Lazy.State GHC.Bool.Bool GHC.Types.Double GHC.Show.Show Data.Vector.Vector Data.Map.Map System.Process.Internals.CreateProcess
Warning: Blockify: could not find link destinations for:
    GHC.Types.Int GHC.Classes.Eq Data.Data.Data GHC.Classes.Ord GHC.Read.Read GHC.Show.Show Data.Typeable.Typeable GHC.Base.String Data.Typeable.Typeable1 GHC.Num.Num Control.Monad.Trans.State.Lazy.State
Warning: Interpreter: could not find …

动机.我正在尝试创建一个monad变换器,其中包含一个特殊指令f <||> g,意思是"重复此整个块包含f <||> g,一次使用f,下一次使用g".这可以用于DSL转换,但您可以想象其他应用程序.

示例用法.该computation单子表达不同的可能的选择(在这种情况下,物联网打印).该printme函数说明了如何处理每个不同的结果.在这种情况下,我们在运行之前打印"开始计算",之后打印"---".

computation = do
    lift (print "start -- always")
    (lift (print "first choice") <||> lift (print "second choice"))
    lift (print "intermediate -- always")
    (lift (print "third choice") <||> lift (print "fourth choice"))
    lift (print "end -- always")

printme x = do
    putStrLn "=== start computation"
    xv <- x
    putStrLn "---\n"
    return xv

test = runIndep printme computation

输出如下,

=== start computation …

在回答有关stackoverflow的问题时,我注意到GHCi(交互式)在let语句中分配了一个限制性太强的类型.即,给定代码,

import Control.Arrow
f = maximum &&& id >>> fst &&& (\(m,l) -> length $ filter (==m) l)

(作为我的回答对/sf/ask/439726941/#6283594),如果一次性插入"让"之前f和在ghci中输入它,它提供以下类型信息

Prelude Control.Arrow> :t f
f :: [()] -> ((), Int)

而只是要求表达式的类型给出正确的结果,即Ord a => [a] -> (a, Int).我正在使用ghc 7.0.3.

注意:这篇文章完全改写了2011-06-10; 感谢彼得帮助我.另外,如果我不接受一个答案,请不要被冒犯,因为这个问题似乎相当开放.(但是,如果你解决它,你当然会得到复选标记).

另一位用户发布了有关并行化合并排序的问题.我以为我会写一个简单的解决方案,但唉,它并不比顺序版快得多.

问题陈述

合并排序是一种分而治之的算法,其中计算的叶子可以并行化.

代码的工作原理如下:将列表转换为树,表示计算节点.然后,合并步骤返回每个节点的列表.从理论上讲,我们应该看到一些重要的性能增益,因为我们将从O(n log n)算法转变为具有无限处理器的O(n)算法.

当参数l(水平)大于零时,计算的第一步是并行化的.这是通过[经由可变完成STRAT ]选择RPAR策略,这将使得子计算归并"×发生在具有平行归并" Y.然后,我们合并结果,并使用rdeepseq强制进行评估.

data Tree a = Leaf a | Node (Tree a) (Tree a) deriving (Show)

instance NFData a => NFData (Tree a) where
    rnf (Leaf v) = deepseq v ()
    rnf (Node x y) = deepseq (x, y) ()

listToTree [] = error "listToTree -- empty list"
listToTree [x] = Leaf x
listToTree xs …

是否有任何版本的split通用列表类型？例如,在Haskell中

Prelude> import Data.List.Split
Prelude Data.List.Split> splitWhen (==2) [1, 2, 3]
[[1],[3]]