(index ("countq" 0) ("countv" 0) ("counte" 0) ("countp" 0) ("count-if" 0) ("count-if-not" 0) ("findq" 264) ("findv" 264) ("finde" 264) ("findp" 264) ("find-if" 264) ("find-if-not" 264) ("positionq" 516) ("positionv" 516) ("positione" 516) ("position" 516) ("positionp" 516) ("position-if" 516) ("position-if-not" 516) ("vector-positione" 516) ("remove-if" 925) ("remove-if-not" 925) ("removee" 925) ("removep" 925) ("removeq" 925) ("removev" 925) ("remove-duplicatesq" 1201) ("remove-duplicatesv" 1201) ("remove-duplicates" 1201) ("remove-duplicatese" 1201) ("list-set!" 1459) ("list-insert" 1459) ("list-remove" 1459) ("list-replace" 1459) ("equivalence-classesq" 1671) ("equivalence-classesv" 1671) ("equivalence-classes" 1671) ("equivalence-classese" 1671) ("transitive-equivalence-classes" 1671) ("adjoinq" 2030) ("adjoinv" 2030) ("adjoin" 2030) ("adjoinp" 2030) ("rest" 2206) ("but-last" 2206) ("sublist" 2206) ("every-other" 2206) ("take-until" 2394) ("drop-until" 2394) ("group-by" 2536) ("sort" 2702) ("lexicographically<?" 2782) ("minimal-membersp" 2782) ("unzip" 2924) ("enumerate" 2995) ("enumerate-vector" 2995) ("some" 3166) ("some-n" 3166) ("some-vector" 3166) ("every-n" 3166) ("every-vector" 3166) ("one" 3166) ("one-n" 3166) ("one-vector" 3166) ("pairwise?" 3526) ("for-each-n" 3641) ("for-each-n-decreasing" 3641) ("map-n" 3641) ("map-n-vector" 3641) ("for-each-from-a-up-to-b" 3641) ("for-each-m-n" 3641) ("for-each-m-n-indexed" 3641) ("for-each-m-n-dec" 3641) ("map-m-n" 3641) ("map-m-n-indexed" 3641) ("for-each-vector" 4217) ("map-vector" 4217) ("map-linear" 4414) ("reduce-n" 4542) ("reduce-vector" 4542) ("map-reduce" 4542) ("map-reduce-n" 4542) ("map-reduce-vector" 4542) ("map-reduce2" 4542) ("map-reduce3" 4542) ("for-each-indexed" 4975) ("map-indexed" 4975) ("for-each-indexed-vector" 4975) ("map-indexed-vector" 4975) ("map-medial" 5309) ("all-pairs" 5509) ("map-all-pairs" 5509) ("memp" 5674) ("assp" 5674) ("map-accum" 5826) ("set-unionq" 5954) ("set-unionv" 5954) ("set-union" 5954) ("set-unione" 5954) ("set-unionvt" 5954) ("set-differenceq" 6203) ("set-differencev" 6203) ("set-difference" 6203) ("set-differencee" 6203) ("set-differencevt" 6203) ("set-intersectionq" 6502) ("set-intersectionv" 6502) ("set-intersection" 6502) ("set-intersectione" 6502) ("set-intersectionvt" 6502) ("set-equalq?" 6821) ("set-equalv?" 6821) ("set-equale?" 6821) ("set-equal?" 6821) ("subsetq?" 7029) ("subsetv?" 7029) ("subsete?" 7029) ("subset?" 7029) ("subsetvt?" 7029) ("ring-backward" 7258) ("ring-forward" 7258) ("ring-forward-between" 7258) ("ring-forward-to" 7258) ("maximump" 7555) ("minimump" 7555) ("maximum" 7555) ("minimum" 7555) ("maximum-with-position" 7555) ("minimum-with-position" 7555) ("sum" 7910) ("sum" 7910) ("sum" 7910) ("product" 7910) ("product" 7910) ("product" 7910) ("factorial" 8140) ("choose" 8140) ("qfind" 8234) ("qcount" 8234) ("qposition" 8234) ("qremove" 8234) ("qremove-duplicates" 8234) ("qtopological-sort" 8234) ("qset-difference" 8234) ("qset-intersection" 8234) ("qset-union" 8234) ("qset-equal?" 8234) ("qreduce" 8234) ("qreduce-vector" 8234) ("qreduce-n" 8234) ("qmap-reduce" 8234) ("qmap-reduce-n" 8234) ("qmap-reduce-vector" 8234) ("qequivalence-classes" 8234) ("qtransitive-equivalence-classesp" 8234) ("qmaximum" 8234) ("qminimum" 8234) ("qmaximump" 8234) ("qminimump" 8234))
(def (sig (procedure "(countq x l)" (id countq)) (procedure "(countv x l)" (id countv)) (procedure "(counte x l)" (id counte)) (procedure "(countp p x l)" (id countp)) (procedure "(count-if p l)" (id count-if)) (procedure "(count-if-not p l)" (id count-if-not))))
(def (sig (procedure "(findq x l)" (id findq)) (procedure "(findv x l)" (id findv)) (procedure "(finde x l)" (id finde)) (procedure "(findp p x l)" (id findp)) (procedure "(find-if p l)" (id find-if)) (procedure "(find-if-not p l)" (id find-if-not))))
(def (sig (procedure "(positionq x l)" (id positionq)) (procedure "(positionv x l)" (id positionv)) (procedure "(positione x l)" (id positione)) (procedure "(position p l)" (id position)) (procedure "(positionp p x l)" (id positionp)) (procedure "(position-if p l)" (id position-if)) (procedure "(position-if-not p l)" (id position-if-not)) (procedure "(vector-positione val vector)" (id vector-positione))))
(def (sig (procedure "(remove-if p l)" (id remove-if)) (procedure "(remove-if-not p l)" (id remove-if-not)) (procedure "(removee x l)" (id removee)) (procedure "(removep p x l)" (id removep)) (procedure "(removeq x l)" (id removeq)) (procedure "(removev x l)" (id removev))))
(def (sig (procedure "(remove-duplicatesq l)" (id remove-duplicatesq)) (procedure "(remove-duplicatesv l)" (id remove-duplicatesv)) (procedure "(remove-duplicates p l)" (id remove-duplicates)) (procedure "(remove-duplicatese x l)" (id remove-duplicatese))))
(def (sig (procedure "(list-set! l i x)" (id list-set!)) (procedure "(list-insert l i x)" (id list-insert)) (procedure "(list-remove l i)" (id list-remove)) (procedure "(list-replace l i x)" (id list-replace))))
(def (sig (procedure "(equivalence-classesq x)" (id equivalence-classesq)) (procedure "(equivalence-classesv x)" (id equivalence-classesv)) (procedure "(equivalence-classes p x)" (id equivalence-classes)) (procedure "(equivalence-classese x)" (id equivalence-classese)) (procedure "(transitive-equivalence-classes p x)" (id transitive-equivalence-classes))))
(def (sig (procedure "(adjoinq x l)" (id adjoinq)) (procedure "(adjoinv x l)" (id adjoinv)) (procedure "(adjoin x l)" (id adjoin)) (procedure "(adjoinp p x l)" (id adjoinp))))
(def (sig (procedure "(rest l)" (id rest)) (procedure "(but-last l)" (id but-last)) (procedure "(sublist list start end)" (id sublist)) (procedure "(every-other list)" (id every-other))))
(def (sig (procedure "(take-until p l)" (id take-until)) (procedure "(drop-until p l)" (id drop-until))) (p "Misc list manipulation stuff."))
(def (sig (procedure "(group-by key l)" (id group-by))) (p "Find equivalence classes of the elements of l that are " (i "equal?") " given output of " (i "key") "."))
(def (sig (procedure "(sort list predicate key)" (id sort))) (p "Merge sort."))
(def (sig (procedure "(lexicographically<? <? =?)" (id lexicographically<?)) (procedure "(minimal-membersp <? =? l)" (id minimal-membersp))))
(def (sig (procedure "(unzip l)" (id unzip))) (p "Transposes lists."))
(def (sig (procedure "(enumerate n)" (id enumerate)) (procedure "(enumerate-vector n)" (id enumerate-vector))) (p "Produce a list or a vector containing 0 through n-1."))
(def (sig (procedure "(some p l)" (id some)) (procedure "(some-n p n)" (id some-n)) (procedure "(some-vector p v)" (id some-vector)) (procedure "(every-n p n)" (id every-n)) (procedure "(every-vector p v)" (id every-vector)) (procedure "(one p l . &rest)" (id one)) (procedure "(one-n p n)" (id one-n)) (procedure "(one-vector p v . &rest)" (id one-vector))))
(def (sig (procedure "(pairwise? p l)" (id pairwise?))) (p "Does p hold on each adjacent pair of elements in l."))
(def (sig (procedure "(for-each-n f n)" (id for-each-n)) (procedure "(for-each-n-decreasing f n)" (id for-each-n-decreasing)) (procedure "(map-n f n)" (id map-n)) (procedure "(map-n-vector f n)" (id map-n-vector)) (procedure "(for-each-from-a-up-to-b f a b)" (id for-each-from-a-up-to-b)) (procedure "(for-each-m-n f m n)" (id for-each-m-n)) (procedure "(for-each-m-n-indexed f m n)" (id for-each-m-n-indexed)) (procedure "(for-each-m-n-dec f m n)" (id for-each-m-n-dec)) (procedure "(map-m-n f m n)" (id map-m-n)) (procedure "(map-m-n-indexed f m n)" (id map-m-n-indexed))))
(def (sig (procedure "(for-each-vector f v . &rest)" (id for-each-vector)) (procedure "(map-vector f v . &rest)" (id map-vector))) (p "Like 'vector-map' but take an arbitrary number of vectors."))
(def (sig (procedure "(map-linear f start end n)" (id map-linear))) (p "Map linearly between 'start' and 'end' in 'n' steps."))
(def (sig (procedure "(reduce-n f i n)" (id reduce-n)) (procedure "(reduce-vector f i v)" (id reduce-vector)) (procedure "(map-reduce g i f l . ls)" (id map-reduce)) (procedure "(map-reduce-n g i f n)" (id map-reduce-n)) (procedure "(map-reduce-vector g i f v . vs)" (id map-reduce-vector)) (procedure "(map-reduce2 g i f l)" (id map-reduce2)) (procedure "(map-reduce3 g i f l1 l2)" (id map-reduce3))) (p "Reduces are left folds."))
(def (sig (procedure "(for-each-indexed f l)" (id for-each-indexed)) (procedure "(map-indexed f l)" (id map-indexed)) (procedure "(for-each-indexed-vector f v)" (id for-each-indexed-vector)) (procedure "(map-indexed-vector f v . &rest)" (id map-indexed-vector))) (p "Passes 'f' both the element and an offset into the list/vector."))
(def (sig (procedure "(map-medial f l key)" (id map-medial))) (p "'f' is passed each adjacent pair of elements in l after being sorted by the key. Key must return a number given each element of l."))
(def (sig (procedure "(all-pairs l)" (id all-pairs)) (procedure "(map-all-pairs f l)" (id map-all-pairs))) (p "'f' is passed each adjacent pair of elements in l."))
(def (sig (procedure "(memp p x l)" (id memp)) (procedure "(assp p x alist)" (id assp))) (p "Like memq and assq but take a predicate for comparison."))
(def (sig (procedure "(map-accum f i l)" (id map-accum))) (p "f will be passed the accumulator and each element of the list."))
(def (sig (procedure "(set-unionq x y)" (id set-unionq)) (procedure "(set-unionv x y)" (id set-unionv)) (procedure "(set-union p x y)" (id set-union)) (procedure "(set-unione x y)" (id set-unione)) (procedure "(set-unionvt x y)" (id set-unionvt))))
(def (sig (procedure "(set-differenceq x y)" (id set-differenceq)) (procedure "(set-differencev x y)" (id set-differencev)) (procedure "(set-difference p x y)" (id set-difference)) (procedure "(set-differencee x y)" (id set-differencee)) (procedure "(set-differencevt x y)" (id set-differencevt))))
(def (sig (procedure "(set-intersectionq x y)" (id set-intersectionq)) (procedure "(set-intersectionv x y)" (id set-intersectionv)) (procedure "(set-intersection p x y)" (id set-intersection)) (procedure "(set-intersectione x y)" (id set-intersectione)) (procedure "(set-intersectionvt x y)" (id set-intersectionvt))))
(def (sig (procedure "(set-equalq? x y)" (id set-equalq?)) (procedure "(set-equalv? x y)" (id set-equalv?)) (procedure "(set-equale? x y)" (id set-equale?)) (procedure "(set-equal? p x y)" (id set-equal?))))
(def (sig (procedure "(subsetq? x y)" (id subsetq?)) (procedure "(subsetv? x y)" (id subsetv?)) (procedure "(subsete? x y)" (id subsete?)) (procedure "(subset? p x y)" (id subset?)) (procedure "(subsetvt? x y)" (id subsetvt?))))
(def (sig (procedure "(ring-backward l)" (id ring-backward)) (procedure "(ring-forward l)" (id ring-forward)) (procedure "(ring-forward-between r a b)" (id ring-forward-between)) (procedure "(ring-forward-to l o)" (id ring-forward-to))) (p "These manipulate a list while treating it as a ring."))
(def (sig (procedure "(maximump l)" (id maximump)) (procedure "(minimump l)" (id minimump)) (procedure "(maximum p l)" (id maximum)) (procedure "(minimum p l)" (id minimum)) (procedure "(maximum-with-position l)" (id maximum-with-position)) (procedure "(minimum-with-position l)" (id minimum-with-position))) (p "p is a function that returns a number."))
(def (sig (procedure "(sum l)" (id sum)) (procedure "(sum p n)" (id sum)) (procedure "(sum p l)" (id sum)) (procedure "(product l)" (id product)) (procedure "(product p n)" (id product)) (procedure "(product p l)" (id product))))
(def (sig (procedure "(factorial n)" (id factorial)) (procedure "(choose n m)" (id choose))))
(def (sig (procedure "(qfind x l)" (id qfind)) (procedure "(qcount x l)" (id qcount)) (procedure "(qposition x l)" (id qposition)) (procedure "(qremove x l)" (id qremove)) (procedure "(qremove-duplicates l)" (id qremove-duplicates)) (procedure "(qtopological-sort p l)" (id qtopological-sort)) (procedure "(qset-difference x y)" (id qset-difference)) (procedure "(qset-intersection x y)" (id qset-intersection)) (procedure "(qset-union x y)" (id qset-union)) (procedure "(qset-equal? x y)" (id qset-equal?)) (procedure "(qreduce f l i)" (id qreduce)) (procedure "(qreduce-vector f v i)" (id qreduce-vector)) (procedure "(qreduce-n f n i)" (id qreduce-n)) (procedure "(qmap-reduce g i f l . ls)" (id qmap-reduce)) (procedure "(qmap-reduce-n g i f n)" (id qmap-reduce-n)) (procedure "(qmap-reduce-vector g i f v . vs)" (id qmap-reduce-vector)) (procedure "(qequivalence-classes x)" (id qequivalence-classes)) (procedure "(qtransitive-equivalence-classesp p x)" (id qtransitive-equivalence-classesp)) (procedure "(qmaximum l)" (id qmaximum)) (procedure "(qminimum l)" (id qminimum)) (procedure "(qmaximump l p)" (id qmaximump)) (procedure "(qminimump l p)" (id qminimump))))
