(index ("ordered-subset-for-each" 0) ("ordered-subset-for-each" 0) ("ordered-subset-fold" 885) ("ordered-subset-fold" 885) ("ordered-subset-map" 1825) ("ordered-subset-map" 1825) ("unordered-subset-for-each" 2462) ("unordered-subset-for-each" 2462) ("unordered-subset-fold" 3420) ("unordered-subset-fold" 3420) ("unordered-subset-map" 4376) ("unordered-subset-map" 4376) ("permutation-for-each" 5029) ("permutation-fold" 5287) ("permutation-map" 5517) ("combination-for-each" 5740) ("combination-fold" 6006) ("combination-map" 6244))
(def (sig (procedure "(ordered-subset-for-each f list) → unspecified" (id ordered-subset-for-each)) (procedure "(ordered-subset-for-each f list k) → unspecified" (id ordered-subset-for-each))) (p "Iterate over every " (i "k") "-permutation (partial ordered subset) of " (tt "list") ", calling " (tt "f") " for its side effect.") (dl (dt (tt "f")) (dd "The function to call") (dt (tt "list")) (dd "The list to permute") (dt (tt "k")) (dd (i "k") " distinct elements (default: " (i "n") ")")) (highlight scheme "(define ordered-subset-for-each\n  (case-lambda\n    ((f list) (ordered-subset-for-each f list (length list)))\n    ((f list k)\n     (let iter ((list list) (k k) (subset '()))\n       (if (zero? k)\n         (f subset)\n         (for-each\n           (lambda (element)\n             (iter (delete element list) (sub1 k) (cons element subset)))\n           list))))))"))
(def (sig (procedure "(ordered-subset-fold cons nil list) → object" (id ordered-subset-fold)) (procedure "(ordered-subset-fold cons nil list k) → object" (id ordered-subset-fold))) (p "Recombine every " (i "k") "-permutation (partial ordered subset) of " (tt "list") ", starting with a base-case " (tt "nil") ", and calling " (tt "cons") " with 1. a permutation and 2. the accumulated value.") (dl (dt (tt "cons")) (dd "The combining function") (dt (tt "nil")) (dd "The base case") (dt (tt "list")) (dd "The list to recombine") (dt (tt "k")) (dd (i "k") " distinct elements (default: " (i "n") ")")) (highlight scheme "(define ordered-subset-fold\n  (case-lambda\n    ((cons nil list) (ordered-subset-fold cons nil list (length list)))\n    ((cons nil list k)\n     (let ((nil (make-parameter nil)))\n       (ordered-subset-for-each\n         (lambda (subset) (nil (cons subset (nil))))\n         list\n         k)\n       (nil)))))"))
(def (sig (procedure "(ordered-subset-map f list) → list" (id ordered-subset-map)) (procedure "(ordered-subset-map f list k) → list" (id ordered-subset-map))) (p "Map every " (i "k") "-permutation (partial ordered subset) of " (tt "list") " using " (tt "f") ".") (dl (dt (tt "f")) (dd "The mapping function") (dt (tt "list")) (dd "The list to map") (dt (tt "k")) (dd (i "k") " distinct elements (default: " (i "n") ")")) (highlight scheme "(define ordered-subset-map\n  (case-lambda\n    ((f list) (ordered-subset-map f list (length list)))\n    ((f list k)\n     (ordered-subset-fold (lambda (v a) (cons (f v) a)) '() list k))))"))
(def (sig (procedure "(unordered-subset-for-each f list) → unspecified" (id unordered-subset-for-each)) (procedure "(unordered-subset-for-each f list k) → unspecified" (id unordered-subset-for-each))) (p "Iterate over every " (i "k") "-combination (partial unordered subset) of " (tt "list") ", calling " (tt "f") " for its side effect.") (dl (dt (tt "f")) (dd "The function to call") (dt (tt "list")) (dd "The list to permute") (dt (tt "k")) (dd (i "k") " distinct elements (default: " (i "n") ")")) (highlight scheme "(define unordered-subset-for-each\n  (case-lambda\n    ((f list) (unordered-subset-for-each f list (length list)))\n    ((f list k)\n     (let ((subset (make-vector k)) (n (length list)))\n       (let iter ((start 0) (p 0))\n         (if (= p k)\n           (f (project subset list))\n           (do ((i start (+ i 1)))\n               ((= i n))\n             (vector-set! subset p i)\n             (iter (add1 i) (add1 p)))))))))"))
(def (sig (procedure "(unordered-subset-fold cons nil list) → object" (id unordered-subset-fold)) (procedure "(unordered-subset-fold cons nil list k) → object" (id unordered-subset-fold))) (p "Recombine every " (i "k") "-combination (partial unordered subset) of " (tt "list") ", starting with a base-case " (tt "nil") ", and calling " (tt "cons") " with 1. a combination and 2. the accumulated value.") (dl (dt (tt "cons")) (dd "The combining function") (dt (tt "nil")) (dd "The base case") (dt (tt "list")) (dd "The list to recombine") (dt (tt "k")) (dd (i "k") " distinct elements (default: " (i "n") ")")) (highlight scheme "(define unordered-subset-fold\n  (case-lambda\n    ((cons nil list) (unordered-subset-fold cons nil list (length list)))\n    ((cons nil list k)\n     (let ((nil (make-parameter nil)))\n       (unordered-subset-for-each\n         (lambda (subset) (nil (cons subset (nil))))\n         list\n         k)\n       (nil)))))"))
(def (sig (procedure "(unordered-subset-map f list) → list" (id unordered-subset-map)) (procedure "(unordered-subset-map f list k) → list" (id unordered-subset-map))) (p "Map every " (i "k") "-combination (partial unordered subset) of " (tt "list") " using " (tt "f") ".") (dl (dt (tt "f")) (dd "The mapping function") (dt (tt "list")) (dd "The list to map") (dt (tt "k")) (dd (i "k") " distinct elements (default: " (i "n") ")")) (highlight scheme "(define unordered-subset-map\n  (case-lambda\n    ((f list) (unordered-subset-map f list (length list)))\n    ((f list k)\n     (unordered-subset-fold (lambda (v a) (cons (f v) a)) '() list k))))"))
(def (sig (constant "permutation-for-each → ordered-subset-for-each" (id permutation-for-each))) (p "Synonym for " (int-link "#ordered-subset-for-each" "ordered-subset-for-each")) (highlight scheme "(define permutation-for-each ordered-subset-for-each)"))
(def (sig (constant "permutation-fold → ordered-subset-fold" (id permutation-fold))) (p "Synonym for " (int-link "#ordered-subset-fold" "ordered-subset-fold")) (highlight scheme "(define permutation-fold ordered-subset-fold)"))
(def (sig (constant "permutation-map → ordered-subset-map" (id permutation-map))) (p "Synonym for " (int-link "#ordered-subset-map" "ordered-subset-map")) (highlight scheme "(define permutation-map ordered-subset-map)"))
(def (sig (constant "combination-for-each → unordered-subset-for-each" (id combination-for-each))) (p "Synonym for " (int-link "#unordered-subset-for-each" "unordered-subset-for-each")) (highlight scheme "(define combination-for-each unordered-subset-for-each)"))
(def (sig (constant "combination-fold → unordered-subset-fold" (id combination-fold))) (p "Synonym for " (int-link "#unordered-subset-fold" "unordered-subset-fold")) (highlight scheme "(define combination-fold unordered-subset-fold)"))
(def (sig (constant "combination-map → unordered-subset-map" (id combination-map))) (p "Synonym for " (int-link "#unordered-subset-map" "unordered-subset-map")) (highlight scheme "(define combination-map unordered-subset-map)"))
