lazy-sequences

How can I create what other languages call a lazy sequence or a "generator" function? In Python, I can use yield as in the following example (from Python's docs) to lazily generate a sequence that is iterable in a way that does not use the memory of an intermediary list: # 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)) How can I do something similar in Rust? Lucian Rust 1.0 does not have generator functions, so you'd have to do it manually with explicit iterators . First, rewrite your

I was under the impression that the lazy seqs were always chunked. => (take 1 (map #(do (print \.) %) (range))) (................................0) As expected 32 dots are printed because the lazy seq returned by range is chunked into 32 element chunks. However, when instead of range I try this with my own function get-rss-feeds , the lazy seq is no longer chunked: => (take 1 (map #(do (print \.) %) (get-rss-feeds r))) (."http://wholehealthsource.blogspot.com/feeds/posts/default") Only one dot is printed, so I guess the lazy-seq returned by get-rss-feeds is not chunked. Indeed: => (chunked-seq

I'm trying to print out my binary tree but Clojure is giving me a hard time printing out the sequences properly. So, I have a list of nodes '(1 2 3) for example. In each iteration I want to print out the node with a number of spaces before and after each element. (defn spaces [n] (apply str (repeat n " "))) Great, this seems to work. So, suppose I have a list of nodes '(:a :b :c) I want to print out on one line, with as said, the spaces. (println (map #(str (spaces before) % (spaces (dec before))) nodes)) I have a list of items. Using the map I get a list of string objects. Great, so I can

I like Clojure. One thing that bothers me about the language is that I don't know how lazy sequences are implemented, or how they work. I know that lazy sequences only evaluate the items in the sequence that are asked for. How does it do this? What makes lazy sequences so efficient that they don't consume much stack? How come you can wrap recursive calls in a lazy sequence and no longer get a stack over flow for large computations? What resources do lazy sequences consume to do what it does? In what scenarios are lazy sequences inefficient? In what scenarios are lazy sequences most efficient?

Both of these interfaces define only one method public operator fun iterator(): Iterator<T> Documentation says Sequence is meant to be lazy. But isn't Iterable lazy too (unless backed by a Collection )? 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