(index ("ilist-null" 0) ("ilist-cons" 122) ("ilists" 374) ("ilist?" 458) ("ilist" 531) ("ilist->ilist" 628) ("ilist-repeat" 718) ("ilist-iterate" 850) ("ilist-iterate-while" 1034) ("ilist-iterate-until" 1246) ("ilist->list" 1458) ("ilist-apply" 1610) ("ilist-null?" 1739) ("ilist-first" 1834) ("ilist-rest" 1949) ("ilist-reverse" 2062) ("ilist-length" 2211) ("ilist-from-upto" 2294) ("ilist-item" 2394) ("ilist-split-at" 2511) ("ilist-split-with" 2671) ("ilist-drop" 2840) ("ilist-drop-while" 2957) ("ilist-take" 3101) ("ilist-take-while" 3238) ("ilist-append" 3412) ("ilist-map" 3498) ("ilist-mappend" 3578) ("ilist-for-each" 3687) ("ilist-filter" 3782) ("ilist-adjoin" 3962) ("ilist-equal?" 4103) ("ilist-memp" 4303) ("ilist-member" 4452) ("ilist-remp" 4570) ("ilist-remove" 4702) ("ilist-remove-dups" 4837) ("ilist-assp" 4961) ("ilist-assoc" 5106) ("ilist-fold-left" 5306) ("ilist-fold-right" 5417) ("ilist-merge" 5531) ("ilist-insert-sorted" 5643) ("ilist-insertion-sort" 5802) ("ilist-merge-sort" 5937) ("ilist-sorted?" 6060) ("ilist-zip" 6178) ("ilist-zip" 6359) ("ilist-interpose" 6516) ("ilist-every?" 6662) ("ilist-some" 6768) ("ilist-not-every?" 6883) ("ilist-not-any?" 7019) ("ilist-in?" 7149) ("ilist-bind" 7296) ("ilist->set" 7840) ("set?" 8005) ("set" 8098) ("set->ilist" 8204) ("set-in?" 8337) ("set<=" 8446) ("set>=" 8524) ("set=" 8602) ("set-filter" 8675) ("set-null?" 8781) ("set-add" 8862) ("set-remove" 8950) ("set-cardinality" 9127) ("set-difference" 9252) ("set-union" 9368) ("set-intersection" 9484))
(def (sig (procedure "(ilist-null)" (id ilist-null))) (p "the fundamental datatype-constructor of an empty typed list."))
(def (sig (procedure "(ilist-cons item ilst)" (id ilist-cons))) (p "the fundamental datatype-constructor consing an item to a tlist while checking, if it passes the item? test, one of the two routines exported by the argument module of the functor."))
(def (sig (procedure "(ilists [sym])" (id ilists))) (p "documentation procedure."))
(def (sig (procedure "(ilist? xpr)" (id ilist?))) (p "type predicate."))
(def (sig (procedure "(ilist . args)" (id ilist))) (p "constructor. All args must pass item?."))
(def (sig (procedure "(ilist->ilist lst)" (id ilist->ilist))) (p "another constructor."))
(def (sig (procedure "(ilist-repeat n x)" (id ilist-repeat))) (p "constructs a typed list of length n with items all x of item?."))
(def (sig (procedure "(ilist-iterate n fn x)" (id ilist-iterate))) (p "constructs a typed list of length n by successively applying fn to x. fn must map item? items to item? itesm."))
(def (sig (procedure "(ilist-iterate-while ok? fn x)" (id ilist-iterate-while))) (p "constructs a typed list by successively applying fn to x as long as ok? returns #t. fn must map item? items to item? itesm."))
(def (sig (procedure "(ilist-iterate-until ok? fn x)" (id ilist-iterate-until))) (p "constructs a typed list by successively applying fn to x as long as ok? returns #f. fn must map item? items to item? itesm."))
(def (sig (procedure "(ilist->list lst)" (id ilist->list))) (p "strips type information and immutability. The returned list is a normal Scheme list."))
(def (sig (procedure "(ilist-apply fn . args)" (id ilist-apply))) (p "like apply, but the last argument must be a typed list."))
(def (sig (procedure "(ilist-null? xpr)" (id ilist-null?))) (p "is xpr an empty typed list?"))
(def (sig (procedure "(ilist-first ilst)" (id ilist-first))) (p "like car but with arguments in reversed order."))
(def (sig (procedure "(ilist-rest ilst)" (id ilist-rest))) (p "like cdr but with arguments in reversed order."))
(def (sig (procedure "(ilist-reverse . ilsts)" (id ilist-reverse))) (p "like reverse, but can reverse typed lists of equal length simultaneously."))
(def (sig (procedure "(ilist-length ilst)" (id ilist-length))) (p "like length."))
(def (sig (procedure "(ilist-from-upto from upto ilst)" (id ilist-from-upto))) (p "like sublist."))
(def (sig (procedure "(ilist-item k ilst)" (id ilist-item))) (p "like list-ref, but with reversed argument order."))
(def (sig (procedure "(ilist-split-at k ilst)" (id ilist-split-at))) (p "splits a typed list at index k returning two sublist values, the head and the tail."))
(def (sig (procedure "(ilist-split-with ok? ilst)" (id ilist-split-with))) (p "splits a typed list at the first item passing the ok? predicate. Returns two sublists."))
(def (sig (procedure "(ilist-drop k ilst)" (id ilist-drop))) (p "like list-tail, but with revrsed argument order."))
(def (sig (procedure "(ilist-drop-while ok? ilst)" (id ilist-drop-while))) (p "drops the first items as long as they pass the ok? predicate."))
(def (sig (procedure "(ilist-take k ilst)" (id ilist-take))) (p "returns the head of the typed list upto (but excluding) the index k."))
(def (sig (procedure "(ilist-take-while ok? ilst)" (id ilist-take-while))) (p "returns the longest sublist of a typed list where all items pass ok? starting from index 0."))
(def (sig (procedure "(ilist-append . ilsts)" (id ilist-append))) (p "like append."))
(def (sig (procedure "(ilist-map fn . ilsts)" (id ilist-map))) (p "like map."))
(def (sig (procedure "(ilist-mappend fn . ilsts)" (id ilist-mappend))) (p "combination of map and append."))
(def (sig (procedure "(ilist-for-each fn . ilsts)" (id ilist-for-each))) (p "like for-each."))
(def (sig (procedure "(ilist-filter ok? ilst)" (id ilist-filter))) (p "returns two sublist of a typed list. In the first one all items pass ok?, in the second no one does that."))
(def (sig (procedure "(ilist-adjoin item ilst)" (id ilist-adjoin))) (p "adds an item to a typed list only if it is not allready a member."))
(def (sig (procedure "(ilist-equal? ilst0 ilst1)" (id ilist-equal?))) (p "Are the typed argument lists equal?. All items are compared with equ?, the other exported routine of the functor argument."))
(def (sig (procedure "(ilist-memp ok? ilst)" (id ilist-memp))) (p "returns the sublist of a typed list, starting with the first item passing ok?."))
(def (sig (procedure "(ilist-member item ilst)" (id ilist-member))) (p "like member, items are compared with equ?."))
(def (sig (procedure "(ilist-remp ok? ilst)" (id ilist-remp))) (p "removes all items from a typed list, which pass the ok? test."))
(def (sig (procedure "(ilist-remove item ilst)" (id ilist-remove))) (p "removes all items from a typed list which are equ? to item."))
(def (sig (procedure "(ilist-remove-dups ilst)" (id ilist-remove-dups))) (p "removes all duplicates, compared with equ?."))
(def (sig (procedure "(ilist-assp ok? ilst)" (id ilist-assp))) (p "returns the first pair of a ilist of pairs, whose car passes the ok? test."))
(def (sig (procedure "(ilist-assoc item ilst)" (id ilist-assoc))) (p "like assoc for typed lists of pairs, the cars of which must pass the type predicate item? and the cars are compared with equ?."))
(def (sig (procedure "(ilist-fold-left op base . ilsts)" (id ilist-fold-left))) (p "like fold-left in R7RS."))
(def (sig (procedure "(ilist-fold-right op base . ilsts)" (id ilist-fold-right))) (p "like fold-right in R7RS."))
(def (sig (procedure "(ilist-merge <? ilst0 ilst1)" (id ilist-merge))) (p "merges two <?-sorted typed lists."))
(def (sig (procedure "(ilist-insert-sorted <? item ilst)" (id ilist-insert-sorted))) (p "inserts an item into a sorted typed list without disturbing order."))
(def (sig (procedure "(ilist-insertion-sort <? ilst)" (id ilist-insertion-sort))) (p "insertion sorts a typed list according to <?."))
(def (sig (procedure "(ilist-merge-sort <? ilst)" (id ilist-merge-sort))) (p "merge sorts a typed list according to <?."))
(def (sig (procedure "(ilist-sorted? <? ilst)" (id ilist-sorted?))) (p "is a typed list sorted with respect ot <?."))
(def (sig (procedure "(ilist-zip ilst0 ilst1)" (id ilist-zip))) (p "combines two typed lists in zip mode, i.e. alternating between the items of the left and right argument list."))
(def (sig (procedure "(ilist-zip ilst)" (id ilist-zip))) (p "splits a typed list into two, populating the result values alternating with items from ilst."))
(def (sig (procedure "(ilist-interpose sep ilst)" (id ilist-interpose))) (p "interposes a separator sep of type type between the list's items."))
(def (sig (procedure "(ilist-every? ok? ilst)" (id ilist-every?))) (p "passes every item the ok? test?"))
(def (sig (procedure "(ilist-some ok? ilst)" (id ilist-some))) (p "returns the first item passing the ok? test."))
(def (sig (procedure "(ilist-not-every? ok? ilst)" (id ilist-not-every?))) (p "checks if not every item of ilst passes the ok? test."))
(def (sig (procedure "(ilist-not-any? ok? ilst)" (id ilist-not-any?))) (p "checks if not any item of ilst passes the ok? test."))
(def (sig (procedure "(ilist-in? ilst0 ilst1)" (id ilist-in?))) (p "checks, if the typed list ilst0 is a contiguous sublist of the ilist ilst1."))
(def (sig (syntax "(ilist-bind (x ... . xs) ilst xpr . xprs)" (id ilist-bind))) (p "This macro allows for general pattern matching of typed lists. A more featurefull solution would be to use the bindings macro") (highlight scheme "(use bindings)\n(seq-length-ref-tail! ilist?\n                      ilist-length\n                      (lambda (ilst item) (ilist-item item ilst))\n                      (lambda (ilst item) (ilist-drop item ilst)))") (p "Then you can use bind and friends and freely mix typed lists with other sequence types."))
(def (sig (procedure "(ilist->set lst)" (id ilist->set))) (p "fundamental datatype constructor. Typed sets are implemented as equivalence classes of typed lists."))
(def (sig (procedure "(set? xpr)" (id set?))) (p "evaluates an expression to a typed set?"))
(def (sig (procedure "(set . args)" (id set))) (p "set constructor. All args must pass the item? test."))
(def (sig (procedure "(set->ilist st)" (id set->ilist))) (p "forget set equality, set=, and return to list equality, list-equal?."))
(def (sig (procedure "(set-in? item st)" (id set-in?))) (p "is item of type item? a member of the set st?"))
(def (sig (procedure "(set<= set0 set1)" (id set<=))) (p "subset relation."))
(def (sig (procedure "(set>= set0 set1)" (id set>=))) (p "subset relation."))
(def (sig (procedure "(set= set0 set1)" (id set=))) (p "set equality."))
(def (sig (procedure "(set-filter ok? st)" (id set-filter))) (p "filters a set, returning two subsets."))
(def (sig (procedure "(set-null? xpr)" (id set-null?))) (p "is the set empty?"))
(def (sig (procedure "(set-add item st)" (id set-add))) (p "adds an item to the set."))
(def (sig (procedure "(set-remove item st)" (id set-remove))) (p "removes an item from the set, i.e. remove all items from the underlying listed list, that are equ? to item."))
(def (sig (procedure "(set-cardinality st)" (id set-cardinality))) (p "returns the number of (different!) items in a set."))
(def (sig (procedure "(set-difference set0 set1)" (id set-difference))) (p "removes all items of set1 from set0."))
(def (sig (procedure "(set-union . sts)" (id set-union))) (p "returns the set of all items of all argument sets."))
(def (sig (procedure "(set-intersection . sts)" (id set-intersection))) (p "returns the set of items which are in all argument sets."))
