Rust does have generators, but they are highly experimental and not currently available in stable Rust. Works in stable Rust 1.0 and above Range handles your concrete example. You can use it with the syntactical sugar of ..: fn main() { let sum: u64 = (0..1_000_000).sum(); println!(“{}”, sum) } What if Range didn’t exist? We … Read more
I’ll give a bit of an explanation of how it works internally. First, you must realise that Haskell uses a thing called a thunk for its values. A thunk is basically a value that has not yet been computed yet — think of it as a function of 0 arguments. Whenever Haskell wants to, it … Read more
Let’s do this. • I know that lazy sequences only evaluate the items in the sequence that are asked for, how does it do this? Lazy sequences (henceforth LS, because I am a LP, or Lazy Person) are composed of parts. The head, or the part(s, as really 32 elements are evaluated at a time, … Read more
Here’s a lazy-list Hamming numbers in Prolog using a “generator idiom”. The more I think about it the more it seems to me the lazy lists of Haskell are just open-ended (a.k.a. “difference”) lists of Prolog, and corecursion just a fancy name for the top-down list building of tail recursion modulo cons. Also, Haskell is … Read more
CORRECTED TWICE: A simpler way to un-chunk a lazy sequence: (defn unchunk [s] (when (seq s) (lazy-seq (cons (first s) (unchunk (next s)))))) First version omitted (when … so it returned an infinite seq of nil’s after the input sequence ended. Second version used first instead of seq so it stopped on nil. RE: your … Read more
Normally, definition of primes stream in Richard Bird’s formulation of the sieve of Eratosthenes is self-referential: import Data.List.Ordered (minus, union, unionAll) ps = 2 : minus [3..] — `:` is “cons” (foldr (\p r -> p*p : union [p*p+p, p*p+2*p..] r) [] ps) The primes ps produced by this definition are used as the input … Read more
The key difference lies in the semantics and the implementation of the stdlib extension functions for Iterable<T> and Sequence<T>. For Sequence<T>, the extension functions perform lazily where possible, similarly to Java Streams intermediate operations. For example, Sequence<T>.map { … } returns another Sequence<R> and does not actually process the items until a terminal operation like … Read more
You’re being hit by filter‘s laziness. Change (filter …) to (doall (filter …)) in your recur form and the problem should go away. A more in-depth explanation: The call to filter returns a lazy seq, which materialises actual elements of the filtered seq as required. As written, your code stacks filter upon filter upon filter…, … Read more