这两个接口都只定义了一种方法
public operator fun iterator(): Iterator<T>
文档说Sequence是懒惰的.但是也不是Iterable懒惰(除非由a支持Collection)？
我正在学习Haskell,并且遇到了以下代码:
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
就其工作方式而言,我在解析方面遇到了一些麻烦.它非常整洁,我知道不需要更多内容,但我想了解Haskell在写作时如何设法"填写"文件:
take 50 fibs
有帮助吗？
谢谢!
我正在尝试编写一个简单的筛子函数来计算clojure中的素数.我已经看到了这个关于编写高效的筛分功能的问题,但我不是为了那点呢.现在我只想写一个非常简单(缓慢)的筛子.以下是我的想法:
(defn sieve [potentials primes]
(if-let [p (first potentials)]
(recur (filter #(not= (mod % p) 0) potentials) (conj primes p))
primes))
对于小范围,它工作正常,但导致堆栈溢出大范围:
user=> (sieve (range 2 30) [])
[2 3 5 7 11 13 17 19 23 29]
user=> (sieve (range 2 15000) [])
java.lang.StackOverflowError (NO_SOURCE_FILE:0)
我认为通过使用recur这将是一个非堆栈消耗循环结构？我错过了什么？
我喜欢Clojure.困扰我的一个问题是我不知道如何实现懒惰的序列,或者它们是如何工作的.
我知道懒惰序列只评估序列中要求的项目.它是如何做到的？
有些语言(Haskell,Clojure,Scheme等)有懒惰的评价.懒惰评估的"卖点"之一是无限数据结构.这有什么好处的？能够处理无限数据结构的情况的一些例子显然是有利的吗？
是否可以在Prolog中使用惰性列表？类似于以下内容:
ones([1 | Y]) :- ones(Y).
虽然这显然不起作用.
如何创建其他语言称为惰性序列或"生成器"函数？
在Python中,我可以使用yield如下例子(来自Python的文档)来懒惰地生成一个可以以不使用中间列表的内存的方式迭代的序列:
# a generator that yields items instead of returning a list
def firstn(n):
num = 0
while num < n:
yield num
num += 1
sum_of_first_n = sum(firstn(1000000))
我怎样才能在Rust中做类似的事情？
在做项目euler#2的更多ruby方式中,部分代码是
while((v = fib(i)) < 4_000_000)
s+=v if v%2==0
i+=1
end
有没有办法改变i += 1成更具功能性的编程风格结构？
我能想到的最好的是
Float::MAX.to_i.times do |i|
v = fib(i)
break unless v < 4_000_000
s += v if v%2==0
end
因为你不能调用.times浮点数.
我的印象是懒惰的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 …
在Clojure中,使用惰性序列构造函数很容易创建无限序列.例如,
(def N (iterate inc 0))
返回一个N等价于无限序列的数据对象
(0 1 2 3 ...)
评估该值会N导致无限循环.评估(take 20 N)返回前20个数字.由于序列是惰性的,因此inc只有在您要求时才会迭代该函数.由于Clojure是同质的,因此递归地存储惰性序列.
在R中,是否可以做类似的事情？你能提出一些样本R代码,它产生的数据对象N相当于完全无限的自然数序列吗？评估完整对象N应该会产生一个循环,但类似的东西head(N)应该只返回前导数字.
注意:我对懒惰序列而不是自然数本身更感兴趣.
编辑:以下是Clojure的来源lazy-seq:
(defmacro lazy-seq
"Takes a body of expressions that returns an ISeq or nil, and yields
a Seqable object that will invoke the body only the first time seq
is called, and will cache the result and return it on all subsequent
seq calls. See also …