Foldr Foldl Foldl页面讨论foldl'并定义如下:
foldl' f z [] = z
foldl' f z (x:xs) = let z' = z `f` x
in seq z' $ foldl' f z' xs
这样做是为了避免空间泄漏,即fold'产生恒定大小的结果仅使用恒定空间.
但是,正如这里所指出的,这并不一定有效:
涉及的
seq函数只评估最顶层的构造函数.如果累加器是一个更复杂的对象,那么fold'仍然会建立未评估的thunk.
显而易见的解决办法是改变seq到deepseq如图所示(假设你正在使用NFData):
foldl_strict f z [] = z
foldl_strict f z (x:xs) = let z' = z `f` x
in deepseq z' $ foldl_strict f z' xs
但我觉得这可能是非常低效的,因为整个结构需要deepseq通过循环每次遍历(除非编译器可以静态证明这不是必需的).
然后我尝试了这个:
foldl_stricter f z l …是否有更惯用的方法将嵌套的序列序列更改为嵌套的集合？
def toNestedSet[T](tsss: Seq[Seq[Seq[T]]]): Set[Set[Set[T]]] =
tsss.map(_.map(_.toSet).toSet).toSet
是否可以实现一个可以处理任何深度列表的函数？
有用于产生汉明数的无限流(即所有的正整数公知的解决方案n,其中n = 2^i * 3^j * 5^k).我在F#中以两种不同的方式实现了这一点.第一种方法使用seq<int>.解决方案很优雅,但性能很糟糕.第二种方法使用尾部被包裹的自定义类型Lazy<LazyList<int>>.解决方案很笨重,但性能却令人惊叹.
有人可以解释为什么性能使用seq<int>如此糟糕,如果有办法解决它？谢谢.
方法1使用seq<int>.
// 2-way merge with deduplication
let rec (-|-) (xs: seq<int>) (ys: seq<int>) =
let x = Seq.head xs
let y = Seq.head ys
let xstl = Seq.skip 1 xs
let ystl = Seq.skip 1 ys
if x < y then seq { yield x; yield! xstl -|- ys }
elif x > y then seq { yield y; yield! …这是一个初学者的问题:在Clojure中有没有办法懒洋洋地连接任意数量的序列？我知道有lazy-cat宏,但我想不出它对任意数量序列的正确应用.
我的用例是通过分页(offseted/limited)请求从API延迟加载数据.通过request-fn下面执行的每个请求检索100个结果:
(map request-fn (iterate (partial + 100) 0))
如果没有更多结果,则request-fn返回空序列.这是我停止迭代的时候:
(take-while seq (map request-fn (iterate (partial + 100) 0)))
例如,API最多可以返回500个结果,并且可以模拟为:
(defn request-fn [offset] (when (< offset 500) (list offset)))
如果我想连接结果,我可以使用(apply concat results)但是急切地评估结果序列:
(apply concat (take-while seq (map request-fn (iterate (partial + 100) 0))))
有没有办法如何使用任何一个lazy-cat或其他东西懒洋洋地连接结果序列？
在Erlang中有替代F#"seq"构造吗？例如,在F#中,我可以编写O(1)内存集成功能
let integrate x1 x2 dx f =
let N = int (abs (x2-x1)/dx)
let sum = seq { for i in 0..N do yield dx*f(x1 + dx * (double i)) }
|> Seq.sum
if x2>x1 then sum else -sum
在Erlang中,我有一个使用列表的实现,因此具有O(n)内存要求,这对于这样的简单函数是不可接受的,
create(Dx, N)->[0| create(Dx, N,[])].
create(Dx, 0, Init)->Init;
create(Dx, N, Init)->create(Dx,N-1, [Dx*N |Init]).
integral(X1,X2,Dx, F) ->
N=trunc((X2-X1)/Dx),
Points = create(Dx,N),
Vals = lists:map(fun(X)->F(X)*Dx end, Points),
lists:sum(Vals).
我们知道在F#中,seq是懒惰的评估.我的问题是,如果我有一个数量有限的seq,如何将其转换为包含其所有值的评估数据类型？
> seq { for i in 1 .. 10 do yield i * i };;
val it : seq<int> = seq [1; 4; 9; 16; ...]
非常感谢.
我想:01 02 03 ... 10,11,12 ... 97,98,99
我尝试过使用以下内容:
seq("01":"19") # Doesn't help
paste0("0",seq("01":"19")) # Doesn't help
请提出建议!
我遇到的问题是,索引的查询拒绝使用索引,因为它没有足够的选择性(假设有1.3亿行中的60个符合条件),因此决定使用seqscan.
我面临的问题是seqscan在这种情况下真的不是最好的选择,由于某些原因它获得了非常好的分数,但事实是seqscan只有在之前被查询并且它可以加载所有内容时才能快速运行来自缓冲区/缓存.
与seqscan相比,索引扫描可能稍微慢一点,如果它们的两个都在缓冲区上,但这很少发生,当两个查询都很冷时,索引扫描仍然更快(ms vs秒).
请注意,索引扫描是优越的,因为我正在使用限制子句,因此它应该能够非常快速地获取这几行.
我已将统计值设置为1000(默认值为100)并且为了以防真空吸尘,但是相同的故事.
TLDR:Seq扫描与低选择性索引上的索引扫描,seqscan是首选,但规划者是错误的,seqscan只有在缓存时才会更好,否则会更糟.
查询和计划,请注意索引一是从缓冲区加载而seqscan不完全.
explain (analyze, buffers)
select *
from identities_identity
where email_domain = 'live.com'
limit 100
'Limit (cost=0.00..63.50 rows=100 width=573) (actual time=75215.573..75215.640 rows=100 loops=1)'
' Buffers: shared hit=75113 read=588870'
' -> Seq Scan on identities_identity (cost=0.00..2980008.00 rows=4692733 width=573) (actual time=75215.571..75215.604 rows=100 loops=1)'
' Filter: ((email_domain)::text = 'live.com'::text)'
' Rows Removed by Filter: 54464136'
' Buffers: shared hit=75113 read=588870'
'Planning time: 0.097 ms'
'Execution time: 75215.675 ms'
'Limit (cost=0.57..187.26 rows=100 width=573) (actual time=0.027..0.090 rows=100 loops=1)'
' …Clojure语言中seqs和list之间的区别是什么？
(list [1 2 3]) => ([1 2 3])
(seq [1 2 3]) => ([1 2 3])
这两种形式似乎被评估为相同的结果.
List.Clear对于序列,java或c#等语言的Nim等价是什么？我看到在系统中列出了proc setLen,但我不确定它是否符合我的要求.从描述:
f the current length is greater than the new length, s will be truncated. s
这是否意味着每次我将任何seq len设置为0它将创建一个新的seq实例？