小编Eri*_*ikR的帖子

鉴于CODE参考,是否有可能:

1. 访问该CODE引用的解析树
2. 通过指定CODE引用的解析树来创建一个新的CODE引用,该解析树可以包含^1中返回的解析树的元素

通常我们通过指定源代码在perl中创建子例程,然后解析源代码并将其转换为解析树.

我想编写一个perl函数,它可以通过指定其解析树来创建子例程,并且该解析树可以从某个其他子例程的另一个解析树派生.

可能？

由于某种原因set expandtab,我的.vimrc文件中的命令没有任何效果.

这是我的.vimrc:

" tab settings
set expandtab
set smarttab
set softtabstop=2
set tabstop=2
set shiftwidth=2
set paste

但是,当我运行vi(没有文件名)时,:set命令会发出:

:set
--- Options ---
  helplang=en         shiftwidth=2        ttyfast
  paste               tabstop=2           ttymouse=xterm2
  fileencodings=ucs-bom,utf-8,default,latin1

表示expandtab未设置该选项.通过执行:set expandtab?返回来进一步确认这一点noexpandtab.

我在OSX 10.10上,并vi --help返回:

$ vi --version
VIM - Vi IMproved 7.4 (2013 Aug 10, compiled Jun 20 2016 11:11:25)
MacOS X (unix) version
Included patches: 1-1847
Compiled by Homebrew

为什么我的.vimrc中的某些设置被尊重,但不是 …

在面向对象的语言中,当我需要在已知的生命周期中缓存/记忆函数的结果时,我通常会遵循以下模式:

1. 创建一个新类
2. 为我想要缓存的每个函数结果添加一个数据成员和方法
3. 实现该方法以首先检查结果是否已存储在数据成员中.如果是,则返回该值; else调用函数(使用适当的参数)并将返回的结果存储在数据成员中.
4. 将使用各种函数调用所需的值初始化此类的对象.

这种基于对象的方法非常类似于此处描述的基于函数的memoization模式:http://www.bardiak.com/2012/01/javascript-memoization-pattern.html

这种方法的主要好处是结果只保留缓存对象的生命周期.常见的用例是处理工作项列表.对于每个工作项,一个为该项创建缓存对象,使用该缓存对象处理工作项,然后在继续下一个工作项之前丢弃工作项和缓存对象.

在Haskell中实现短暂存储的好方法是什么？答案取决于要缓存的函数是纯粹还是涉及IO？

只是重申 - 看到涉及IO的功能的解决方案会很高兴.

我有8 GB的RAM,但Haskell程序似乎只能使用1.3 GB.

我正在使用这个简单的程序来确定GHC程序可以分配多少内存:

import System.Environment
import Data.Set as Set

main = do
         args <- getArgs
         let n = (read $ args !! 0) :: Int
             s = Set.fromList [0..n]
         do
           putStrLn $ "min: " ++ (show $ findMin s)
           putStrLn $ "max: " ++ (show $ findMax s)

这是我发现的:

• 运行./mem.exe 40000000 +RTS -s成功并报告1113 MB total memory in use
• 运行./mem.exe 42000000 +RTS -s失败了out of memory error
• 运行./mem.exe 42000000 +RTS -s -M4G错误-M4G: …

我有一个2-d numpy字符串数组.有没有办法连接每一行中的字符串,然后用分隔符字符串连接结果字符串,例如换行符？

例:

pic = np.array([ 'H','e','l','l','o','W','o','r','l','d']).reshape(2,5)

我想得到:

"Hello\nWorld\n"

当我执行查询并右键单击结果区域时,我会看到一个弹出菜单,其中包含以下选项:

• 将网格另存为报告...
• 单记录视图...
• 伯爵......
• 查找/突出显示...
• 出口 ...

如果我选择"Count Rows",如果它开始耗时太长,有没有办法中断操作？

我遇到了这一系列命令的问题:

wget http://hackage.haskell.org/package/github-0.7.1/github-0.7.1.tar.gz
tar zxf github-0.7.1.tar.gz
cd github-0.7.1
ghci samples/Users/ShowUser.hs

我得到的错误是:

Github/Private.hs:142:0:
     error: missing binary operator before token "("

Github/Private.hs:148:0:
     error: missing binary operator before token "("
phase `C pre-processor' failed (exitcode = 1)

那是因为Github/Private.hs模块使用的 cpp在两个地方指令:

#if MIN_VERSION_http_conduit(1, 9, 0)
    successOrMissing s@(Status sci _) hs cookiejar
#else
    successOrMissing s@(Status sci _) hs
#endif
      | (200 <= sci && sci < 300) || sci == 404 = Nothing
#if MIN_VERSION_http_conduit(1, 9, 0)
      | otherwise = Just $ E.toException $ StatusCodeException …

我想知道我在多大程度上担心微优化Haskell中的公共子表达式(使用GHC),特别是在数据解构方面.

例如,请考虑使用此代码合并两个有序列表:

merge :: Ord a => [a] -> [a] -> [a]
merge [] bs = bs
merge as [] = as
merge (a:as) (b:bs) =
  case compare a b of
    LT -> a : merge as (b:bs)  -- (1)
    EQ -> a : merge as bs
    GT -> b : merge (a:as) bs  -- (2)

GHC会认识到(a:as)at(2)和(b:bs)at(1)与输入参数相同吗？或者,我应该使用"as"模式,例如:

merge a'@(a:as) b'@(b:bs) =
  ...
  LT -> a : merge as b'
  ...
  GT -> b : merge a' …

根据Monad Reader第8期中的文章,我使用功能依赖和类型系列编写了"Instant Insanity"拼图的类型级解决方案:

• fundeps解决方案:http://lpaste.net/113108
• 类型家庭解决方案:http://lpaste.net/113113

fundeps解决方案大约需要200秒.而类型族版本在大约800秒内完成.

是否有任何技术可以使类型族版本更有效地运行？

我正在尝试编写代码以在Haskell中执行以下简单任务:使用此字典查找单词的词源,存储为大型tsv文件(http://www1.icsi.berkeley.edu/~demelo/etymwn/).我以为我会将tsv文件解析(使用attoparsec)到Map中,然后我可以根据需要使用它来高效地查找词源(并做一些其他的事情).

这是我的代码:

{-# LANGUAGE OverloadedStrings #-}

import Control.Arrow
import qualified Data.Map as M
import Control.Applicative
import qualified Data.Text as DT
import qualified Data.Text.Lazy.IO as DTLIO
import qualified Data.Text.Lazy as DTL
import qualified Data.Attoparsec.Text.Lazy as ATL
import Data.Monoid

text = do
    x <- DTLIO.readFile "../../../../etymwn.tsv"
    return $ DTL.take 10000 x

--parsers
wordpair = do
    x <- ATL.takeTill (== ':')
    ATL.char ':' *> (ATL.many' $ ATL.char ' ')
    y <- ATL.takeTill (\x -> x `elem` ['\t','\n'])
    ATL.char '\n' <|>   ATL.char …