(index ("lazy-lists" 0) ("Make-lazy" 206) ("Lazy" 297) ("List?" 426) ("List-finite?" 503) ("List-infinite?" 594) ("List-not-null?" 692) ("Lists-one-finite?" 790) ("Admissible?" 939) ("Length" 1158) ("Cons" 1264) ("Rest" 1397) ("Cdr" 1470) ("First" 1541) ("Car" 1616) ("At" 1687) ("Ref" 1827) ("Null?" 1906) ("Zip" 1983) ("Unzip" 2090) ("Some?" 2260) ("Every?" 2353) ("Fold-right*" 2449) ("Fold-left*" 2594) ("Fold-right" 2707) ("Fold-left" 2847) ("Sieve" 2984) ("Split-with" 3083) ("Split-at" 3211) ("List->vector" 3305) ("vector->List" 3417) ("Sort" 3529) ("Merge" 3628) ("Sorted?" 3746) ("Cycle" 3857) ("Reverse*" 3991) ("Reverse" 4089) ("Append" 4192) ("Range" 4342) ("Iterate" 4471) ("Repeatedly" 4623) ("Repeat" 4776) ("input->List" 4896) ("For-each" 5020) ("Filter" 5191) ("Remp" 5275) ("Remove" 5380) ("Remq" 5495) ("Remv" 5603) ("Map" 5712) ("Assoc" 5827) ("Assv" 5909) ("Assq" 5988) ("Assp" 6067) ("Equal?" 6173) ("Eqv?" 6259) ("Eq?" 6339) ("Equ?" 6416) ("Member" 6514) ("Memv" 6598) ("Memq" 6676) ("Memp" 6754) ("Count-while" 6844) ("Drop-while" 6961) ("Take-while" 7083) ("Drop" 7201) ("Take" 7310) ("List" 7394) ("list->List" 7498) ("List->list" 7609) ("Realize" 7715) ("Realized?" 7796) ("Primes" 7876) ("Cardinals" 7956) ("assume-in" 8050))
(def (sig (procedure "(lazy-lists [sym])" (id lazy-lists))) (p "documentation procedure: returns a sorted list of all exported symbols with no argument or the signature of sym when called with argument."))
(def (sig (procedure "(Make-lazy finite? thunk)" (id Make-lazy))) (p "lazy constructor."))
(def (sig (syntax "(Lazy finite? xpr . xprs)" (id Lazy))) (p "convenience wrapper to Make-lazy constructor, avoiding a thunk."))
(def (sig (procedure "(List? xpr)" (id List?))) (p "lazy version of list?"))
(def (sig (procedure "(List-finite? xpr)" (id List-finite?))) (p "is xpr a finite List?"))
(def (sig (procedure "(List-infinite? xpr)" (id List-infinite?))) (p "is xpr an infinite List?"))
(def (sig (procedure "(List-not-null? xpr)" (id List-not-null?))) (p "is xpr a non-empty List?"))
(def (sig (procedure "(Lists-one-finite? . Lsts)" (id Lists-one-finite?))) (p "is Lsts a nonempty list of Lists, at least one of it being finite?"))
(def (sig (procedure "(Admissible? n Lst)" (id Admissible?))) (p "checks if n is an admissible index for the lazy-list Lst. Deprecated, makes finite Lists eager. Moreover traverses a List twice, when used in a check"))
(def (sig (procedure "(Length Lst)" (id Length))) (p "lazy version of length, returning a fixnum or #f"))
(def (sig (procedure "(Cons var Lst)" (id Cons))) (p "lazy version of cons. Deprecated, use (Lazy finite? (cons var Lst)) instead"))
(def (sig (procedure "(Rest Lst)" (id Rest))) (p "lazy version of cdr"))
(def (sig (procedure "(Cdr Lst)" (id Cdr))) (p "lazy version of cdr"))
(def (sig (procedure "(First Lst)" (id First))) (p "lazy version of car"))
(def (sig (procedure "(Car Lst)" (id Car))) (p "lazy version of car"))
(def (sig (procedure "(At n Lst)" (id At))) (p "lazy version of list-ref with changed argument order, realizing the Lst argument upto n."))
(def (sig (procedure "(Ref n Lst)" (id Ref))) (p "alias for At, deprecated."))
(def (sig (procedure "(Null? Lst)" (id Null?))) (p "lazy version of null?"))
(def (sig (procedure "(Zip Lst1 Lst2)" (id Zip))) (p "interleave two lazy lists, both might be infinite"))
(def (sig (procedure "(Unzip Lst)" (id Unzip))) (p "splits a lazy list in two by alternatingly putting the items of Lst into the first or the second result lazy list."))
(def (sig (procedure "(Some? ok? Lst)" (id Some?))) (p "does some item of Lst fulfill ok?"))
(def (sig (procedure "(Every? ok? Lst)" (id Every?))) (p "does every item of Lst fulfill ok?"))
(def (sig (procedure "(Fold-right* op base Lst . Lsts)" (id Fold-right*))) (p "create a lazy list of right folds changing order or List items"))
(def (sig (procedure "(Fold-left* op base Lst . Lsts)" (id Fold-left*))) (p "create a lazy list of left folds"))
(def (sig (procedure "(Fold-right op base Lst . Lsts)" (id Fold-right))) (p "lazy version of fold-right, one of the Lsts must be finite."))
(def (sig (procedure "(Fold-left op base Lst . Lsts)" (id Fold-left))) (p "lazy version of fold-left, one of the Lsts must be finite."))
(def (sig (procedure "(Sieve =? Lst)" (id Sieve))) (p "sieve of Erathostenes with respect to =?"))
(def (sig (procedure "(Split-with ok? Lst)" (id Split-with))) (p "split a finite lazy list at first index not fulfilling ok?"))
(def (sig (procedure "(Split-at n Lst)" (id Split-at))) (p "split a List at fixed position"))
(def (sig (procedure "(List->vector Lst)" (id List->vector))) (p "transform a finite lazy list into a vector"))
(def (sig (procedure "(vector->List vec)" (id vector->List))) (p "transform a vector into a finite lazy list"))
(def (sig (procedure "(Sort <? Lst)" (id Sort))) (p "sort a finite lazy list with respect to <?"))
(def (sig (procedure "(Merge <? Lst1 Lst2)" (id Merge))) (p "merge two sorted finite lazy lists with respect to <?"))
(def (sig (procedure "(Sorted? <? Lst)" (id Sorted?))) (p "is the finite lazy lst sorted with respect to <?"))
(def (sig (procedure "(Cycle [n] Lst)" (id Cycle))) (p "create finite List of Length n or infinite List by cycling finite List Lst"))
(def (sig (procedure "(Reverse* Lst)" (id Reverse*))) (p "List of successive reversed subLists"))
(def (sig (procedure "(Reverse Lst)" (id Reverse))) (p "lazy version of reverse. Lst must be finite"))
(def (sig (procedure "(Append . Lsts)" (id Append))) (p "lazy version of append. If one of the Lsts is infinite, it's the last one to be appended."))
(def (sig (procedure "(Range [from] upto [step])" (id Range))) (p "List of integers from (included) upto (excluded) with step"))
(def (sig (procedure "(Iterate fn x [times])" (id Iterate))) (p "create finite List of Length times or infinite List by applying fn succesively to x"))
(def (sig (procedure "(Repeatedly thunk [times])" (id Repeatedly))) (p "create finite List of Length times or infinite List of return values of thunk"))
(def (sig (procedure "(Repeat x [times])" (id Repeat))) (p "create finite List of Length times or infinite List of x"))
(def (sig (procedure "(input->List port read-proc)" (id input->List))) (p "transform input port into List with read-proc"))
(def (sig (procedure "(For-each proc . Lsts)" (id For-each))) (p "lazy version of for-each. At least one of the Lsts must be finite. For-each terminates at its length."))
(def (sig (procedure "(Filter ok? Lst)" (id Filter))) (p "lazy version of filter"))
(def (sig (procedure "(Remp ok? Lst)" (id Remp))) (p "removes all items which pass the ok? predicate."))
(def (sig (procedure "(Remove item Lst)" (id Remove))) (p "removes all items form Lst which are equal? to item."))
(def (sig (procedure "(Remq item Lst)" (id Remq))) (p "removes all items form Lst which are eq? to item."))
(def (sig (procedure "(Remv item Lst)" (id Remv))) (p "removes all items form Lst which are eqv? to item."))
(def (sig (procedure "(Map proc . Lsts)" (id Map))) (p "lazy version of map, terminates at the shortest Length."))
(def (sig (procedure "(Assoc key aLst)" (id Assoc))) (p "lazy version of assoq"))
(def (sig (procedure "(Assv key aLst)" (id Assv))) (p "lazy version of assv"))
(def (sig (procedure "(Assq key aLst)" (id Assq))) (p "lazy version of assq"))
(def (sig (procedure "(Assp ok? aLst)" (id Assp))) (p "return #f or first pair, whose Car fulfills ok?"))
(def (sig (procedure "(Equal? Lst1 Lst2)" (id Equal?))) (p "lazy version of equal?"))
(def (sig (procedure "(Eqv? Lst1 Lst2)" (id Eqv?))) (p "lazy version of eqv?"))
(def (sig (procedure "(Eq? Lst1 Lst2)" (id Eq?))) (p "lazy version of eq?"))
(def (sig (procedure "(Equ? =? Lst1 Lst2)" (id Equ?))) (p "compare two Lists with predicate =?"))
(def (sig (procedure "(Member var Lst)" (id Member))) (p "lazy version of member"))
(def (sig (procedure "(Memv var Lst)" (id Memv))) (p "lazy version of memv"))
(def (sig (procedure "(Memq var Lst)" (id Memq))) (p "lazy version of memq"))
(def (sig (procedure "(Memp ok? Lst)" (id Memp))) (p "Tail of items not fulfilling ok?"))
(def (sig (procedure "(Count-while ok? Lst)" (id Count-while))) (p "return index of first item not fulfilling ok?"))
(def (sig (procedure "(Drop-while ok? Lst)" (id Drop-while))) (p "Tail of items not fulfilling ok? Lst must be finite."))
(def (sig (procedure "(Take-while ok? Lst)" (id Take-while))) (p "List of items fulfilling ok? Lst must be finite."))
(def (sig (procedure "(Drop n Lst)" (id Drop))) (p "lazy version of list-tail with changed argument order"))
(def (sig (procedure "(Take n Lst)" (id Take))) (p "List of first n items of Lst"))
(def (sig (procedure "(List . args)" (id List))) (p "lazy version of list. Constructs a finite List."))
(def (sig (procedure "(list->List lst)" (id list->List))) (p "transform ordinary list into finite lazy list"))
(def (sig (procedure "(List->list Lst)" (id List->list))) (p "transform finite lazy into ordinary list"))
(def (sig (procedure "(Realize Lst)" (id Realize))) (p "realize a finite List"))
(def (sig (procedure "(Realized? Lst)" (id Realized?))) (p "Is Lst realized?"))
(def (sig (procedure "(Primes)" (id Primes))) (p "lazy list of prime numbers"))
(def (sig (procedure "(Cardinals)" (id Cardinals))) (p "lazy list of non negative integers"))
(def (sig (syntax "(assume-in sym test . tests)" (id assume-in))) (p "Checks if all the assumptions test ... in the routine with name sym are valid and provides a meaningful error-message otherwise, provided the feature assumptions-checked is registered.  Checks nothing if the feature is not registered."))
