(index ("array-handlers" 0) ("array-handler?" 100) ("make-array-handler" 189) ("array-handler-repeat" 391) ("array-handler-iterate" 602) ("array-handler-iterate-while" 849) ("array-handler-iterate-until" 1142) ("array-handler-messages" 1441) ("nary" 1595) ("nary?" 1704) ("assert*" 1829) ("arrays" 1938) ("array?" 2022) ("array-null?" 2095) ("make-array" 2206) ("array" 2367) ("list->array" 2508) ("vector->array" 2654) ("array-repeat" 2807) ("array-iterate" 2966) ("array-iterate-while" 3181) ("array-iterate-until" 3442) ("array-copy" 3709) ("array->list" 3818) ("array->vector" 3926) ("array-cursor-start!" 4040) ("array-cursor-next!" 4217) ("array-cursor-goto!" 4424) ("array-cursor-finished?" 4576) ("array-cursor-item" 4724) ("array-cursor-index" 4843) ("array-memp" 4965) ("array-member" 5118) ("array-memq" 5238) ("array-memv" 5351) ("array-handler" 5465) ("array-first" 5587) ("array-rest" 5689) ("array-last" 5787) ("array-butlast" 5895) ("array-add!" 6024) ("array-update!" 6141) ("array-prune!" 6274) ("array-apply" 6391) ("array-reverse" 6554) ("array-reverse!" 6674) ("array-swap!" 6790) ("array-length" 6909) ("array-count" 7012) ("array-range" 7130) ("array-ref" 7290) ("array-item" 7393) ("array-split-at" 7498) ("array-split-with" 7633) ("array-tail" 7805) ("array-drop" 7897) ("array-drop-while" 7989) ("array-take" 8118) ("array-take-while" 8210) ("array-append" 8339) ("array-append!" 8515) ("array-map" 8692) ("array-mappend" 8939) ("array-for-each" 9112) ("array-filter" 9288) ("array-equ?" 9527) ("array-equal?" 9766) ("array-eqv?" 9877) ("array-eq?" 9982) ("array-remp" 10084) ("array-remove" 10233) ("array-remq" 10358) ("array-remv" 10476) ("array-remove-dups" 10595) ("array-fold-left" 10743) ("array-fold-right" 10892) ("array-sorted?" 11044) ("array-sort!" 11172) ("array-zip" 11339) ("array-unzip" 11514) ("array-interpose" 11654) ("array-every?" 11823) ("array-some?" 11946) ("array-in?" 12066) ("array-bind" 12173) ("array-sets" 12805) ("set?" 12897) ("set-null?" 12966) ("make-set" 13071) ("set-iterate" 13219) ("set-iterate-while" 13437) ("set-iterate-until" 13703) ("list->set" 13975) ("vector->set" 14148) ("set" 14327) ("set->list" 14485) ("set->vector" 14577) ("set-in" 14675) ("set<=" 14810) ("set=" 14922) ("set>=" 15058) ("set-filter" 15166) ("set-map" 15388) ("set-for-each" 15673) ("set-add!" 15815) ("set-remove!" 15905) ("set-count" 16010) ("set-copy" 16103) ("set-difference" 16193) ("set-union" 16406) ("set-intersection" 16602) ("set-every?" 16836) ("set-some?" 16953) ("set-apply" 17067) ("set-handler" 17237) ("set-equ?" 17346) ("set-item?" 17454))
(def (sig (procedure "(array-handlers [sym])" (id array-handlers))) (p "documentation procedure."))
(def (sig (procedure "(array-handler? xpr)" (id array-handler?))) (p "type predicate."))
(def (sig (procedure "(make-array-handler [item?])" (id make-array-handler))) (p "creates a new empty array-handler closure, which accepts items of type item?. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-handler-repeat [item?] cnt item)" (id array-handler-repeat))) (p "stores item of type item? cnt times in a new empty array-handler closure. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-handler-iterate [item?] cnt fn start)" (id array-handler-iterate))) (p "iterates function fn cnt times, starting with start of type item?, to make a new array-handler closure. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-handler-iterate-while [item?] ok? fn start)" (id array-handler-iterate-while))) (p "iterates function fn, starting with start of type item?, as long as fn's result passes the ok? test, to make a new array-handler closure. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-handler-iterate-until [item?] ok? fn start)" (id array-handler-iterate-until))) (p "iterates function fn, starting with start of type item?, as long as fn's result doesn't pass the ok? test, to make a new array-handler closure. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-handler-messages)" (id array-handler-messages))) (p "returns the list of messages, accepted by the array-handler closure."))
(def (sig (procedure "(nary binop)" (id nary))) (p "helper procedure, which makes a binary operator nary."))
(def (sig (procedure "(nary? bincmp?)" (id nary?))) (p "helper procedure, which makes a binary comparison procedure nary."))
(def (sig (syntax "(assert* loc . xprs)" (id assert*))) (p "checks xprs in sequence in the procedure loc."))
(def (sig (procedure "(arrays [sym])" (id arrays))) (p "documentation procedure."))
(def (sig (procedure "(array? xpr)" (id array?))) (p "type predicate."))
(def (sig (procedure "(array-null? xpr)" (id array-null?))) (p "checks, if xpr evaluates to an empty array."))
(def (sig (procedure "(make-array [item?])" (id make-array))) (p "fundamental constructor. Returns an empty array with item type item? which defaults to any?"))
(def (sig (procedure "(array [item?] . args)" (id array))) (p "The argument list args, which must be nonempty, is transformed to an arry."))
(def (sig (procedure "(list->array [item?] lst)" (id list->array))) (p "The argument list is transformed to a new arry. item? defaults to any?"))
(def (sig (procedure "(vector->array [item?] vec)" (id vector->array))) (p "The argument vector is transformed to a new array. item? defaults to any?"))
(def (sig (procedure "(array-repeat [item?] cnt item)" (id array-repeat))) (p "stores item cnt times in a new array. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-iterate [item?] cnt fn start)" (id array-iterate))) (p "iterates function fn cnt times, starting with start of type item?, to make a new array. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-iterate-while [item?] ok? fn start)" (id array-iterate-while))) (p "iterates function fn, starting with start of type item?, as long as fn's result passes the ok? test, to make a new array. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-iterate-until [item?] ok? fn start)" (id array-iterate-until))) (p "iterates function fn, starting with start of type item?, as long as fn's result doesn't pass the ok? test, to make a new array. If no item? is supplied, any? is used."))
(def (sig (procedure "(array-copy arr)" (id array-copy))) (p "creates a fresh copy of its array argument."))
(def (sig (procedure "(array->list arr)" (id array->list))) (p "transforms its array argument to a list."))
(def (sig (procedure "(array->vector arr)" (id array->vector))) (p "transforms its array argument to a vector."))
(def (sig (procedure "(array-cursor-start! arr)" (id array-cursor-start!))) (p "begins a travere of its array argument. Positions the cursor to the left of the lowest index."))
(def (sig (procedure "(array-cursor-next! arr)" (id array-cursor-next!))) (p "continues a travere of its array argument. To access an item, at least one move after array-cursor-start! must have happened."))
(def (sig (procedure "(array-cursor-goto! ok? arr)" (id array-cursor-goto!))) (p "traverses the array util its cursor-item passes the ok? predicate."))
(def (sig (procedure "(array-cursor-finished? arr)" (id array-cursor-finished?))) (p "checks, if the cursor has reached the end of the traverse."))
(def (sig (procedure "(array-cursor-item arr)" (id array-cursor-item))) (p "returns the current item of the cursor."))
(def (sig (procedure "(array-cursor-index arr)" (id array-cursor-index))) (p "returns the current index of the cursor."))
(def (sig (procedure "(array-memp ok? arr)" (id array-memp))) (p "drops the first array items, which don't pass ok?. Returns #f if no item passes ok?"))
(def (sig (procedure "(array-member item arr)" (id array-member))) (p "same as (array-memp (cut equal? <> item) arr)"))
(def (sig (procedure "(array-memq item arr)" (id array-memq))) (p "same as (array-memp (cut eq? <> item) arr)"))
(def (sig (procedure "(array-memv item arr)" (id array-memv))) (p "same as (array-memp (cut eqv? <> item) arr)"))
(def (sig (procedure "(array-handler arr)" (id array-handler))) (p "returns the underlying array-handler of the array."))
(def (sig (procedure "(array-first arr)" (id array-first))) (p "returns the array item at index 0."))
(def (sig (procedure "(array-rest arr)" (id array-rest))) (p "drops the array item at index 0."))
(def (sig (procedure "(array-last arr)" (id array-last))) (p "returns the array item with highest index."))
(def (sig (procedure "(array-butlast arr)" (id array-butlast))) (p "takes all the array items except that with highest index."))
(def (sig (procedure "(array-add! item arr)" (id array-add!))) (p "adds an item after the highest index position."))
(def (sig (procedure "(array-update! index new arr)" (id array-update!))) (p "updates the item at index position with a new item."))
(def (sig (procedure "(array-prune! arr)" (id array-prune!))) (p "removes the item at the highest index position."))
(def (sig (procedure "(array-apply fn . args)" (id array-apply))) (p "applies procedure fn to args, which must be a nonempty list, whose last item is an array."))
(def (sig (procedure "(array-reverse arr)" (id array-reverse))) (p "creates a new array with items in reverse order."))
(def (sig (procedure "(array-reverse! arr)" (id array-reverse!))) (p "reverses the array destructively in place."))
(def (sig (procedure "(array-swap! k l arr)" (id array-swap!))) (p "exchanges the array items at positions k and l."))
(def (sig (procedure "(array-length arr)" (id array-length))) (p "the length of its argument array."))
(def (sig (procedure "(array-count arr)" (id array-count))) (p "the number of items stored in the array's handler."))
(def (sig (procedure "(array-range from upto arr)" (id array-range))) (p "returns the subarray starting at index from (included) upto index upto (excluded)."))
(def (sig (procedure "(array-ref arr k)" (id array-ref))) (p "returns the item at index position k."))
(def (sig (procedure "(array-item k arr)" (id array-item))) (p "returns the item at index position k."))
(def (sig (procedure "(array-split-at k arr)" (id array-split-at))) (p "splits the array at index position k, returning two values."))
(def (sig (procedure "(array-split-with ok? arr)" (id array-split-with))) (p "splits the array at the first index position, whose item passes ok?, returning two values."))
(def (sig (procedure "(array-tail arr k)" (id array-tail))) (p "drops the first k items."))
(def (sig (procedure "(array-drop k arr)" (id array-drop))) (p "drops the first k items."))
(def (sig (procedure "(array-drop-while ok? arr)" (id array-drop-while))) (p "drops the first items as long as they pass ok?."))
(def (sig (procedure "(array-take k arr)" (id array-take))) (p "takes the first k items."))
(def (sig (procedure "(array-take-while ok? arr)" (id array-take-while))) (p "takes the first items as long as they pass ok?."))
(def (sig (procedure "(array-append . arrs)" (id array-append))) (p "creates a new array by appending all of its argument arrays, provided they all have the same item type."))
(def (sig (procedure "(array-append! . arrs)" (id array-append!))) (p "appends destructively the arrays of (cdr args) to (car args). All arrays must have the same item type."))
(def (sig (procedure "(array-map [item?] fn . arrs)" (id array-map))) (p "maps the array arguments to a new array with item? (or any? if not provided) by means of function fn. The length of the new array is the minimum of the lengthes of arrs."))
(def (sig (procedure "(array-mappend fn . arrs)" (id array-mappend))) (p "combination of map and append: The same as (array-apply array-append (apply array-map fn arrs))"))
(def (sig (procedure "(array-for-each proc . arrs)" (id array-for-each))) (p "applies procedure proc to the array arguments, until the first array argument reaches its end."))
(def (sig (procedure "(array-filter ok? arr)" (id array-filter))) (p "filters the array argument with respect to the predicate ok? Returns two values, the array of those items, which passed the test, and the array of those which don't."))
(def (sig (procedure "(array-equ? equ? . arrs)" (id array-equ?))) (p "checks if the array arguments are equal, where the items are compared with equ?. Moreover all array arguments must be of the same length and have the same item type."))
(def (sig (procedure "(array-equal? . arrs)" (id array-equal?))) (p "the same as (array-equ? equal? . arrs)"))
(def (sig (procedure "(array-eqv? . arrs)" (id array-eqv?))) (p "the same as (array-equ? eqv? . arrs)"))
(def (sig (procedure "(array-eq? . arrs)" (id array-eq?))) (p "the same as (array-equ? eq? . arrs)"))
(def (sig (procedure "(array-remp ok? arr)" (id array-remp))) (p "removes all items of arr which pass the ok? test. Second value of array-filter."))
(def (sig (procedure "(array-remove item arr)" (id array-remove))) (p "the same as (array-remp (cut equal? <> item) arr)."))
(def (sig (procedure "(array-remq item arr)" (id array-remq))) (p "the same as (array-remp (cut eq? <> item) arr)."))
(def (sig (procedure "(array-remv item arr)" (id array-remv))) (p "the same as (array-remp (cut eqv? <> item) arr)."))
(def (sig (procedure "(array-remove-dups equ? arr)" (id array-remove-dups))) (p "removes all duplicates of arr according to comparison wiht equ?"))
(def (sig (procedure "(array-fold-left op base . arrs)" (id array-fold-left))) (p "folds the arrays arrs from the left with op, starting at base."))
(def (sig (procedure "(array-fold-right op base . arrs)" (id array-fold-right))) (p "folds the arrays arrs from the right with op, starting at base."))
(def (sig (procedure "(array-sorted? <? arr)" (id array-sorted?))) (p "checks, if the array arr is sorted with respect to <?"))
(def (sig (procedure "(array-sort! <? arr)" (id array-sort!))) (p "destructively sorts the array argument in place with a combination of insertion- and quick-sort."))
(def (sig (procedure "(array-zip arr0 arr1)" (id array-zip))) (p "combines two arrays to one, by taking items alternately from both. Both arrays must have equal item type."))
(def (sig (procedure "(array-unzip arr)" (id array-unzip))) (p "splits an array into two by populating its two array values alternately."))
(def (sig (procedure "(array-interpose sep arr)" (id array-interpose))) (p "creates a new array by separating the items of its array argument with the separator sep."))
(def (sig (procedure "(array-every? ok? arr)" (id array-every?))) (p "checks, if every item of arr passes the ok? test."))
(def (sig (procedure "(array-some? ok? arr)" (id array-some?))) (p "checks, if some item of arr passes the ok? test."))
(def (sig (procedure "(array-in? =? arr0 arr1)" (id array-in?))) (p "checks if arr0 a subrange of arr1."))
(def (sig (syntax "(array-bind (x ... . xs) arr xpr . xprs)" (id array-bind))) (p "This macro allows for general pattern matching of arrays. Binds x ... to the first items of arr and xs to the remaining subarray and executes the body xpr . xprs in this context. A more featurefull solution would be to use the bindings module:") (highlight scheme "(use bindings)\n(bind-table-add! array?\n                 array-length\n                 (lambda (arr item) (array-item item arr))\n                 (lambda (arr item) (array-drop item arr)))") (p "Then you can use bind and friends and freely mix arrays with other sequence types."))
(def (sig (procedure "(array-sets [sym])" (id array-sets))) (p "documentation procedure."))
(def (sig (procedure "(set? xpr)" (id set?))) (p "type predicate."))
(def (sig (procedure "(set-null? xpr)" (id set-null?))) (p "checks, if xpr evaluates to an empty set."))
(def (sig (procedure "(make-set [equ?])" (id make-set))) (p "creates a new empty set, whose items are compared with equ?, which defaults to eqv?"))
(def (sig (procedure "(set-iterate [equ?] n fn start)" (id set-iterate))) (p "iterates function fn cnt times, starting with start to be compared with equ?, to make a new array. If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(set-iterate-while [equ?] ok? fn start)" (id set-iterate-while))) (p "iterates function fn, starting with start to be compared with equ?, as long as fn's result passes the ok? test, to make a new array. If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(set-iterate-until [equ?] ok? fn start)" (id set-iterate-until))) (p "iterates function fn, starting with start to be compared with equ?, as long as fn's result doesn't pass the ok? test, to make a new array. If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(list->set [equ?] lst)" (id list->set))) (p "transforms a list into a set, whose items are compared with equ? If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(vector->set [equ?] vec)" (id vector->set))) (p "transforms a vector into a set, whose items are compared with equ? If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(set [equ?] . args)" (id set))) (p "creates a new set with items from args compared with equ?. If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(set->list st)" (id set->list))) (p "transforms a set into a list."))
(def (sig (procedure "(set->vector st)" (id set->vector))) (p "transforms a set into a vector."))
(def (sig (procedure "(set-in item st)" (id set-in))) (p "checks, if item is in the set st; if so, returns its index, otherwise #f."))
(def (sig (procedure "(set<= set0 set1)" (id set<=))) (p "checks, if the set set0 contained in the set set1."))
(def (sig (procedure "(set= set0 set1)" (id set=))) (p "checks, if the sets set0 and set1 are equal, i.e. contain the same alements."))
(def (sig (procedure "(set>= set0 set1)" (id set>=))) (p "checks, if the set set0 contains the set set1."))
(def (sig (procedure "(set-filter ok? st)" (id set-filter))) (p "filters the set st with respect to the predicate ok? Returns two values, the set of those items, which passed the test, and the set of those which don't."))
(def (sig (procedure "(set-map [equ?] fn . sets)" (id set-map))) (p "maps the sets with respect to the function fn to a set, whose items are compared with equ? The cardinality of the result is the minimum of the cardinalities of the arguments. If no equ? is supplied, eqv? is used."))
(def (sig (procedure "(set-for-each proc . sets)" (id set-for-each))) (p "applies procedure proc to sets until the first argument is null."))
(def (sig (procedure "(set-add! item st)" (id set-add!))) (p "adds item to the set st."))
(def (sig (procedure "(set-remove! item st)" (id set-remove!))) (p "removes the item from the set st."))
(def (sig (procedure "(set-count st)" (id set-count))) (p "the cardinality of the set st."))
(def (sig (procedure "(set-copy st)" (id set-copy))) (p "creates a copy of the set st."))
(def (sig (procedure "(set-difference set0 set1)" (id set-difference))) (p "creates a new set by removing all items of set0, which are contained in set1. The comparison procedure of both sets must be the same."))
(def (sig (procedure "(set-union . sets)" (id set-union))) (p "creates a new set, which contains all items of all set arguments. The comparison procedure of all set arguments must be the same."))
(def (sig (procedure "(set-intersection . sets)" (id set-intersection))) (p "creates a new set, which contains only those items which are in all of its set arguments. The comparison procedure of all set arguments must be the same."))
(def (sig (procedure "(set-every? ok? st)" (id set-every?))) (p "checks, if every item of st passes the ok? test."))
(def (sig (procedure "(set-some? ok? st)" (id set-some?))) (p "checks, if some item of st passes the ok? test."))
(def (sig (procedure "(set-apply fn . args)" (id set-apply))) (p "applies procedure fn to the arguments args, which must be nonempty and whose last value is an array."))
(def (sig (procedure "(set-handler st)" (id set-handler))) (p "returns the handler closure of the set st."))
(def (sig (procedure "(set-equ? st)" (id set-equ?))) (p "returns the comparison-procedure of the set st."))
(def (sig (procedure "(set-item? st)" (id set-item?))) (p "returns the item? predicate of the set st, computed from its comparison procedure."))
