我的印象是懒惰的seqs总是被分块.
=> (take 1 (map #(do (print \.) %) (range)))
(................................0)
正如预期的那样打印32个点,因为返回的lazy seq range被分成32个元素块.但是,当range我用自己的函数尝试这个时get-rss-feeds,懒惰的seq不再是分块的:
=> (take 1 (map #(do (print \.) %) (get-rss-feeds r)))
(."http://wholehealthsource.blogspot.com/feeds/posts/default")
只打印了一个点,所以我猜测返回的lazy-seq get-rss-feeds没有分块.确实:
=> (chunked-seq? (seq (range)))
true
=> (chunked-seq? (seq (get-rss-feeds r)))
false
以下是来源get-rss-feeds:
(defn get-rss-feeds
"returns a lazy seq of urls of all feeds; takes an html-resource from the enlive library"
[hr]
(map #(:href (:attrs %))
(filter #(rss-feed? (:type (:attrs %))) (html/select hr [:link])))
因此,看起来粗糙取决于懒惰的seq是如何产生的.我偷看了函数的来源,range …
我有一个漫长而懒惰的序列,我想减少并懒惰地测试.一旦两个连续元素彼此不相同=(或某些其他谓词),我想停止使用生产成本高昂的列表.是的,这听起来像是take-while,但请进一步阅读.
我想写一些简单而优雅的东西(假装一分钟every?就像这样reduce):
(every? = (range 100000000))
但这不是懒惰的工作,所以它挂在无限的seqs.我发现这几乎和我想要的一样:
(apply = (range 100000000))
但是,我注意到序列分块导致创建和测试额外的,不必要的元素.至少,这就是我认为这是在下面的代码中发生的事情:
;; Displays chunking behavior in groups of four on my system and prints 1 2 3 4
(apply = (map #(do (println %) %) (iterate inc 1)))
;; This prints 0 to 31
(apply = (map #(do (println %) %) (range)))
我找到了一种解决方法take-while,并count检查所采用的元素数量,但这很麻烦.
我应该礼貌地向Rich Hickey建议他正确地进行了一些组合reduce和every?短路,还是我错过了一些已经存在的明显方法？
编辑:两种人发布了避免在懒惰序列上进行分块的解决方案,但是如何避免在进行分块时使用分块apply,这似乎在四个分组中消耗？
编辑#2:正如Stuart Sierra所说,我独立发现,这实际上并不是分块.它只是正常应用,所以我会把它叫做关闭并给他答案.对于那些感兴趣的人,我在一个单独的答案中包含了一个小函数来完成问题的减少部分.
我正在使用NLTK RegexpParser从标记的标记中提取noungroups和verbgroups.
如何查看生成的树只查找NP或V组的块？
from nltk.chunk import RegexpParser
grammar = '''
NP: {<DT>?<JJ>*<NN>*}
V: {<V.*>}'''
chunker = RegexpParser(grammar)
token = [] ## Some tokens from my POS tagger
chunked = chunker.parse(tokens)
print chunked
#How do I walk the tree?
#for chunk in chunked:
# if chunk.??? == 'NP':
# print chunk
(/ IN(NP载体/ NN)用于/ IN组织/ JJ和/ CC细胞培养/ JJ用于/ IN(NP/DT制备/ NN)/ IN(NP植入物/ NNS)和/ CC(NP植入物)/NN)(V包含/ VBG)(NP/DT载波/ NN)./.)
我正在使用WCF并希望将大文件从客户端上传到服务器.我已调查并决定遵循http://msdn.microsoft.com/en-us/library/aa717050.aspx中列出的分块方法
但是,这种方法(就像流式传输一样)将合同限制为有限的方法签名:
[OperationContract(IsOneWay=true)]
[ChunkingBehavior(ChunkingAppliesTo.InMessage)]
void UploadStream(Stream stream);
该示例使用了相当方便的示例,即从固定路径上载文件并将其保存到服务器上的固定路径.因此,我的问题是如何传递其他参数来指定文件名,文件路径等.
例如.我想要像:
[OperationContract(IsOneWay=true)]
[ChunkingBehavior(ChunkingAppliesTo.InMessage)]
void UploadStream(Stream stream, String filePath);
马克,先谢谢你.
是否存在处理大文件的最佳块大小？我有一个上传服务(WCF),用于接受几百兆字节的文件上传.
我已经尝试了4KB,8KB到1MB的块大小.较大的块大小有利于提高性能(更快的处理速度),但却以内存为代价.
那么,有没有办法在上传文件时计算出最佳的块大小.如何进行这样的计算呢？它是可用内存和客户端,CPU和网络带宽的组合,它决定了最佳尺寸吗？
干杯
编辑:可能应该提到客户端应用程序将处于silverlight状态.
在每第N次出现分隔符后,是否存在将文本文件拆分为多个块/块的单行内容？
示例:下面的分隔符是"+"
entry 1
some more
+
entry 2
some more
even more
+
entry 3
some more
+
entry 4
some more
+
...
有几百万个条目,因此每次出现分隔符"+"时都要分开是一个坏主意.我想分开,例如,每隔50,000个分隔符"+"实例.
Unix命令"split"和"csplit"似乎没有这样做......
我运行一个查询,它目前返回1400结果,因此我在日志文件中收到以下警告:
com.google.appengine.api.datastore.QueryResultsSourceImpl logChunkSizeWarning:此查询没有在FetchOptions中设置的块大小,并返回了超过1000个结果.如果此查询的结果集对此查询很常见,请考虑设置块大小以提高性能.
我找不到任何关于如何实际实现这个的例子,这里有关于python的问题,但是因为我使用java并且不理解python,我正在努力翻译它.
另外这个查询(下面)正在执行17226cpu_ms,这感觉太长了,我甚至无法想象如果我说5000个联系人需要在客户端搜索它们会发生什么(就像你使用googlemail联系人一样! )
我的代码是:
int index=0;
int numcontacts=0;
String[][] DetailList;
PersistenceManager pm = PMF.get().getPersistenceManager();
try {
Query query = pm.newQuery(Contact.class, "AdminID == AID");
query.declareParameters("Long AID");
query.setOrdering("Name asc");
List<Contact> Contacts = (List<Contact>) query.execute(AdminID);
numcontacts=Contacts.size();
DetailList=new String[numcontacts][5];
for (Contact contact : Contacts)
{
DetailList[index][0]=contact.getID().toString();
DetailList[index][1]=Encode.EncodeString(contact.getName());
index++;
}
} finally {
pm.close();
}
return (DetailList);
我在这里找到了以下两个条目:
但实际上并未涉及有关如何实施或使用这些选项的任何细节.我猜它是一个服务器端进程,我猜你要设置某种循环来一次抓取一个块,但我该如何实际做到这一点？
如果没有一个实际的例子,我是怎么想找到这样的东西呢？在我看来,这里的其他人似乎"只知道"该怎么做..!
抱歉,如果我没有以正确的方式提出问题,或者我只是一个愚蠢的新手,但我不知道还有什么可以解决这个问题!
我正在使用create-react-app.
我想知道是否有办法关闭内置在 react 脚本中的分块机制。问题是我需要修复在构建中创建的包的名称。
我正在尝试构造一个Conduit接收为输入ByteStrings(每个块大小约1kb)并生成ByteString512kb块的输出连接.
这看起来应该很简单,但是我遇到了很多麻烦,我尝试过的大多数策略只能成功地将块分成更小的块,我没有成功连接更大的块.
我开始尝试isolate,然后takeExactlyE最终conduitVector,但无济于事.最终我决定这个:
import qualified Data.Conduit as C
import qualified Data.Conduit.Combinators as C
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
chunksOfAtLeast :: Monad m => Int -> C.Conduit B.ByteString m BL.ByteString
chunksOfAtLeast chunkSize = loop BL.empty chunkSize
where
loop buffer n = do
mchunk <- C.await
case mchunk of
Nothing ->
-- Yield last remaining bytes
when (n < chunkSize) (C.yield buffer)
Just chunk -> …