小编npo*_*cop的帖子

我想从 Node.js 对 Haskell 代码进行 RPC 调用。node 和 Haskell 都有哪些库？我只能找到 XML-RPC 和 zeromq，但它们似乎不稳定。

众所周知,kthreadd是一个内核线程,用于帮助其他人创建新的内核线程(kthread_create_list查看是否需要创建任何新的内核线程).

但我不明白为什么我们不使用create_kthread创建新的内核线程？我认为kthreadd没有任何区别.

请你给我一些建议.

谢谢你的大力帮助.

DAG =有向无环图; roots =没有传入边的顶点.

我有一个比可用RAM大的DAG,所以我需要一个基于磁盘的图形数据库来处理它.

我的DAG很浅:我有数十亿个根节点,但是从每个节点只有几十个节点可以访问.

它也没有很好地连接:大多数节点只有一个传入边缘.因此,对于任何一个根节点,可到达的子图通常具有很少的共同节点.

所以我的DAG可以被认为是大量的小树,只有少数几棵相交.

我需要在批量号码上对我的DAG执行以下查询:给定根节点,从中获取所有节点.

它可以被认为是批量查询:给定数千个根节点,返回从那里可到达的所有节点.

据我所知,有一些算法可以改善图形的磁盘存储局部性.三个例子是:

• http://ceur-ws.org/Vol-733/paper_pacher.pdf
• http://www.cs.ox.ac.uk/dan.olteanu/papers/g-store.pdf
• http://graphlab.org/files/osdi2012-kyrola-blelloch-guestrin.pdf

似乎还有老一代图形数据库不使用图形局部性.例如一个流行的Neo4j图形数据库:

http://www.ibm.com/developerworks/library/os-giraph/

Neo4j依赖于图的数据访问方法而不考虑数据局部性,并且图的处理主要需要随机数据访问.对于无法存储在内存中的大型图形,随机磁盘访问成为性能瓶颈.

我的问题是:是否有适合我的工作量的图形数据库？

支持Win64以及从Java以外的其他方式使用数据库的可能性是一个优点.

有示例： https: //github.com/pcapriotti/optparse-applicative/blob/master/tests/Examples/Cabal.hs#L46-L62

parser :: Parser Args
parser = runA $ proc () -> do
  opts <- asA commonOpts -< ()
  cmds <- (asA . hsubparser)
            ( command "install"
              (info installParser
                    (progDesc "Installs a list of packages"))
           <> command "update"
              (info updateParser
                    (progDesc "Updates list of known packages"))
           <> command "configure"
              (info configureParser
                    (progDesc "Prepare to build the package"))
           <> command "build"
              (info buildParser
                    (progDesc "Make this package ready for installation")) ) -< ()
  A version >>> A helper -< …

我希望能够cata从recursion-schemes包中使用Church编码中的列表.

type ListC a = forall b. (a -> b -> b) -> b -> b

为方便起见,我使用了二级排序,但我不在乎.newtype如果您觉得有必要,请随意添加,使用GADT等.

教会编码的概念众所周知且简单:

three :: a -> a -> a -> List1 a 
three a b c = \cons nil -> cons a $ cons b $ cons c nil

基本上是"抽象未指定" cons,nil而不是"正常"构造函数.我相信一切都可以用这种方式编码(Maybe树木等).

很容易证明它List1与普通列表确实是同构的:

toList :: List1 a -> [a]
toList f = f (:) []

fromList :: [a] -> List1 a
fromList …

在System FI中,可以使用Church数字定义真正的总加法函数.

在Haskell中,由于底值,我无法定义该函数.例如,在haskell中,如果x + y = x,那么我不能说y为零 - 如果x是底部,x + y = x表示任何y.因此,加法不是真正的加法,而是对它的近似.

在CI中无法定义该函数,因为C规范要求所有内容都具有有限的大小.所以在C中,可能的近似值甚至比Haskell更差.

所以我们有:

在系统F中,可以定义添加,但不可能有完整的实现(因为没有无限的硬件).

在Haskell中,不可能定义添加(因为底部),并且不可能有完整的实现.

在C中,不可能定义总加法函数(因为所有内容的语义都是有界的),但是可以实现兼容的实现.

因此,所有3个正式系统(Haskell,System F和C)似乎都有不同的设计权衡.

那么选择一个而不是另一个的后果是什么？

我想写一个web服务器,State用wai/ 将它的状态存储在monad中warp.像这样的东西:

{-# LANGUAGE OverloadedStrings #-}
import Network.Wai
import Network.Wai.Handler.Warp
import Network.HTTP.Types
import Control.Monad.State
import Data.ByteString.Lazy.Char8

main = run 3000 app

text x = responseLBS
        status200
        [("Content-Type", "text/plain")]
    x

app req = return $ text "Hello World"

app1 req = modify (+1) >>= return . text . pack . show

-- main1 = runStateT (run 3000 app1) 0

当然,注释行不起作用.目的是将计数器存储在状态monad中,并在每个请求上显示其递增值.

另外,我如何获得线程安全？warp是顺序还是并行运行我的中间件？

有什么选择可用于州 - 除了IORef我可以在这种情况下使用之外还有什么吗？

我理解国家给予安全,但似乎wai不允许国家.

我只需要一个可以从其他地方调用的简单的单线程RPC.Haxr包需要一个单独的Web服务器,这是一个过度的.请参阅从Node.JS调用Haskell - 它没有任何建议,因此我使用Wai/Warp和Aeson编写了一个简单的服务器.但似乎WAI旨在支持并发实现,因此它使事情复杂化.

如果我有键到值的映射,那么键组可以实现为固定虚拟值的键映射.

傻瓜有很多候选人:

• data- 没有构造函数的定义类型
• 其他无人居住的类型(例如forall a . a)
• 单身人士类型
• 未装箱的类型

对我来说最明显的解决方案是使用股票单例类型,()但case我可以区分()底部,所以我认为内存表示()包括间接.

我有两个问题:

• 是否Map.fromList [(1, ()), (2, ())]会比更多的内存let dummy = () in Map.fromList [(1, dummy), (2, dummy)]？
• 考虑到内存占用,CPU使用率和正确性,建议使用bytestring-triedummy构建集合的值是多少？

我正在阅读这篇关于延续的有趣文章,我发现了这个聪明的伎俩.在我自然会使用记录的地方,作者使用一个以和类型作为第一个参数的函数.

例如,而不是这样做

data Processor = Processor { processString :: String -> IO ()
                           , processInt :: Int -> IO ()
                           }


processor = Processor (\s -> print $ "Hello "++ s)
                      (\x -> print $ "value" ++ (show x))

我们做得到:

data Arg = ArgString String | ArgInt Int
processor :: Arg -> IO ()
processor (ArgString s) = print "Hello" ++ s
processor (ArgInt x) = print "value" ++ (show x)

除了聪明之外,它对简单记录有什么好处？这是一种常见的模式吗？它有名字吗？

在250 MB文件中计算不同的行长度时,以下程序使用100+ MB RAM.如何修复它以减少使用RAM？我想我误用懒惰的IO,foldr以及Data.Map价值观的懒惰.

import Control.Applicative
import qualified Data.Map as M
import Data.List

main = do
  content <- readFile "output.csv"
  print $ (foldr count M.empty . map length . lines) content

count a b = M.insertWith (+) a 1 b