(index ("make-lazy-seq" 0) ("lazy-seq" 545) ("lazy-seq?" 705) ("lazy-seq-realized?" 840) ("lazy-null?" 994) ("lazy-list" 1139) ("lazy-null" 1272) ("lazy-seq->list" 1356) ("list->lazy-seq" 1544) ("lazy-head" 1677) ("lazy-tail" 1786) ("lazy-length" 1895) ("lazy-append" 2065) ("lazy-concatenate" 2218) ("lazy-append-map" 2413) ("lazy-reverse" 2655) ("lazy-take" 2939) ("lazy-drop" 3088) ("lazy-take-while" 3245) ("lazy-drop-while" 3427) ("lazy-ref" 3614) ("lazy-map" 3760) ("lazy-filter" 3973) ("lazy-each" 4137) ("lazy-fold" 4356) ("lazy-flatten" 4569) ("lazy-iterate" 4804) ("lazy-repeat" 4999) ("lazy-repeatedly" 5121) ("lazy-cycle" 5314) ("lazy-numbers" 5457) ("input-port->lazy-seq" 5783) ("lazy-seq->string" 6135) ("string->lazy-seq" 6360))
(def (sig (procedure "(make-lazy-seq body)" (id make-lazy-seq))) (p "Returns a " (tt "lazy-seq") " object. " (tt "body") " is a thunk which will be called when the sequence is realized. It is expected to return one of the following things:") (ul (li "The empty list to signify the end of the sequence") (li "A pair with the sequence's head in the " (tt "car") " and a " (tt "lazy-seq") " representing the sequence's tail  in the " (tt "cdr")) (li "Another " (tt "lazy-seq") " which will be realized recursively when the sequence is realized")))
(def (sig (syntax "(lazy-seq body ...)" (id lazy-seq))) (p "Convenience syntax for " (tt "make-lazy-seq") " with " (tt "body ...") " being the thunk's body."))
(def (sig (procedure "(lazy-seq? seq)" (id lazy-seq?))) (p "Predicate for checking whether " (tt "seq") " is a " (tt "lazy-seq") "."))
(def (sig (procedure "(lazy-seq-realized? seq)" (id lazy-seq-realized?))) (p "Predicate for checking whether " (tt "seq") " has already been realized."))
(def (sig (procedure "(lazy-null? seq)" (id lazy-null?))) (p "Predicate for checking whether " (tt "seq") " is null. Realizes " (tt "seq") "."))
(def (sig (procedure "(lazy-list . elements)" (id lazy-list))) (p "Returns a realized " (tt "lazy-seq") " of " (tt "elements") "."))
(def (sig (constant "lazy-null" (id lazy-null))) (p "A null " (tt "lazy-seq") "."))
(def (sig (procedure "(lazy-seq->list seq)" (id lazy-seq->list))) (p "Completely realizes " (tt "seq") " and returns a list of its elements. Should not be called on infinite sequences."))
(def (sig (procedure "(list->lazy-seq list)" (id list->lazy-seq))) (p "Turns " (tt "list") " into a realized " (tt "lazy-seq") "."))
(def (sig (procedure "(lazy-head seq)" (id lazy-head))) (p "Realizes " (tt "seq") " and returns its head."))
(def (sig (procedure "(lazy-tail seq)" (id lazy-tail))) (p "Realizes " (tt "seq") " and returns its tail."))
(def (sig (procedure "(lazy-length seq)" (id lazy-length))) (p "Completely realizes " (tt "seq") " and returns its length. Should not be called on infinite sequences."))
(def (sig (procedure "(lazy-append seqs ...)" (id lazy-append))) (p "Returns a " (tt "lazy-seq") " representing the concatenation of " (tt "seqs") "."))
(def (sig (procedure "(lazy-concatenate seq)" (id lazy-concatenate))) (p "Returns a " (tt "lazy-seq") " representing the concatenation of the " (tt "lazy-seq") "s contained in " (tt "seq") "."))
(def (sig (procedure "(lazy-append-map proc seqs ...)" (id lazy-append-map))) (p "Returns a " (tt "lazy-seq") " which is the concatenation of " (tt "lazy-seq") "s resulting from applying " (tt "proc") " to each element in " (tt "seqs") "."))
(def (sig (procedure "(lazy-reverse seq)" (id lazy-reverse))) (p "Returns a " (tt "lazy-seq") " of the reversed " (tt "seq") ". Note that even realizing just the head of the returned " (tt "lazy-seq") " will realize " (tt "seq") " completely. Infinite sequences can't be reversed."))
(def (sig (procedure "(lazy-take n seq)" (id lazy-take))) (p "Returns a " (tt "lazy-seq") " of the first " (tt "n") " elements of " (tt "seq") "."))
(def (sig (procedure "(lazy-drop n seq)" (id lazy-drop))) (p "Returns a " (tt "lazy-seq") " of all but the first " (tt "n") " elements of " (tt "seq") "."))
(def (sig (procedure "(lazy-take-while pred? seq)" (id lazy-take-while))) (p "Returns a " (tt "lazy-seq") " of all leading elements of " (tt "seq") " satisfying " (tt "pred?") "."))
(def (sig (procedure "(lazy-drop-while pred? seq)" (id lazy-drop-while))) (p "Returns a " (tt "lazy-seq") " of " (tt "seq") " without all leading elements satisfying " (tt "pred?") "."))
(def (sig (procedure "(lazy-ref n seq)" (id lazy-ref))) (p "Realizes " (tt "seq") " up to the " (tt "n") "th element and returns that element."))
(def (sig (procedure "(lazy-map proc seqs ...)" (id lazy-map))) (p "Returns a " (tt "lazy-seq") " of applying " (tt "proc") " to each element in " (tt "seqs") ". Terminates with the sortest of " (tt "seqs") "."))
(def (sig (procedure "(lazy-filter pred? seq)" (id lazy-filter))) (p "Returns a " (tt "lazy-seq") " of elements from " (tt "seq") " satisfying " (tt "pred?") "."))
(def (sig (procedure "(lazy-each proc seqs ...)" (id lazy-each))) (p "Completely realizes " (tt "seqs") " and applies " (tt "proc") " to each item for its side-effect. Terminates with the sortest of " (tt "seqs") "."))
(def (sig (procedure "(lazy-fold kons init seq)" (id lazy-fold))) (p "Completely realizes " (tt "seq") ", iterating over each value and accumulating a result, similar to " (tt "fold") " from " (tt "srfi-1") "."))
(def (sig (procedure "(lazy-flatten seq)" (id lazy-flatten))) (p "Returns a " (tt "lazy-seq") " of elements from " (tt "seq") ", expanding any contained " (tt "lazy-seq") " elements. The result is a single flat " (tt "lazy-seq") "."))
(def (sig (procedure "(lazy-iterate proc x)" (id lazy-iterate))) (p "Returns a " (tt "lazy-seq") " with a head of " (tt "x") " and a tail of applying " (tt "proc") " to the preceding element."))
(def (sig (procedure "(lazy-repeat x)" (id lazy-repeat))) (p "Returns an infinite " (tt "lazy-seq") " of " (tt "x") "."))
(def (sig (procedure "(lazy-repeatedly thunk)" (id lazy-repeatedly))) (p "Returns an infinite " (tt "lazy-seq") " of the return value of " (tt "thunk") " at the time an element is realized."))
(def (sig (procedure "(lazy-cycle seq)" (id lazy-cycle))) (p "Returns a " (tt "lazy-seq") " which infinitely cycles through " (tt "seq") "."))
(def (sig (procedure "(lazy-numbers #!key (step 1) (start 0) count)" (id lazy-numbers))) (p "Returns a " (tt "lazy-seq") " of numbers starting at " (tt "start") " and increasing by " (tt "step") ". When " (tt "count") " is a positive number the sequence terminates after " (tt "count") " elements. Otherwise it is infinte."))
(def (sig (procedure "(input-port->lazy-seq port read)" (id input-port->lazy-seq))) (p "Returns a " (tt "lazy-seq") " of the results of applying " (tt "read") " to " (tt "port") " (which must be an input port). The sequence terminates when " (tt "read") " returns " (tt "#!eof") ". The " (tt "port") " is not closed automatically by this procedure."))
(def (sig (procedure "(lazy-seq->string seq)" (id lazy-seq->string))) (p "Completely realizes a " (tt "seq") " of characters and returns a string consisting of those characters. Should not be called on infinite sequences."))
(def (sig (procedure "(string->lazy-seq string)" (id string->lazy-seq))) (p "Turns " (tt "string") " into a realized " (tt "lazy-seq") " of characters."))
