(index ("left-section" 0) ("right-section" 287) ("crop-left" 577) ("crop-right" 752) ("reversed" 930) ("arguments-chain" 1086) ("arguments-each" 1525) ("arguments-all" 2031) ("group-by" 2388) ("group/key" 2682) ("make-less-than/key" 3062) ("make-equal/key" 3346) ("andf" 3614) ("orf" 3843) ("uni" 4016) ("uni2" 4123) ("uni3" 4236) ("uni-each" 4353) ("uni-all" 4451) ("bi" 4572) ("bi2" 4685) ("bi3" 4806) ("bi-each" 4933) ("bi-all" 5056) ("tri" 5190) ("tri2" 5313) ("tri3" 5446) ("tri-each" 5587) ("tri-all" 5720) ("uni" 5871) ("uni" 5981) ("uni" 5981) ("uni" 5981) ("uni2" 6178) ("uni2" 6294) ("uni2" 6294) ("uni2" 6294) ("uni3" 6497) ("uni3" 6617) ("uni3" 6617) ("uni3" 6617) ("uni@" 6820) ("uni@" 6932) ("bi" 7033) ("bi" 7149) ("bi" 7149) ("bi" 7149) ("bi" 7149) ("bi2" 7392) ("bi2" 7516) ("bi2" 7516) ("bi2" 7516) ("bi2" 7516) ("bi3" 7767) ("bi3" 7897) ("bi3" 7897) ("bi3" 7897) ("bi3" 7897) ("bi@" 8148) ("bi@" 8266) ("tri" 8365) ("tri" 8491) ("tri" 8491) ("tri" 8491) ("tri" 8491) ("tri2" 8746) ("tri2" 8882) ("tri2" 8882) ("tri2" 8882) ("tri2" 8882) ("tri3" 9145) ("tri3" 9289) ("tri3" 9289) ("tri3" 9289) ("tri3" 9289) ("tri@" 9552) ("tri@" 9680) ("dip" 9781) ("dip" 9895) ("dup" 9994) ("dup" 10100) ("dupd" 10197) ("dupd" 10309) ("swap" 10408) ("swap" 10518) ("drop" 10617) ("drop" 10721) ("drop/2" 10820) ("drop/2" 10932))
(def (sig (procedure "(left-section FUNC ARG0 ...) => procedure" (id left-section))) (p "Returns a procedure that partially applies some of its arguments from the left.") (p (tt "ARG0 ...") " a prefix of the arguments for " (tt "FUNC") ".") (p "Returns a partially curried procedure."))
(def (sig (procedure "(right-section FUNC ARG0 ...) => procedure" (id right-section))) (p "Returns a procedure that partially applies some of its arguments from the right.") (p (tt "ARG0 ...") " a suffix of the arguments for " (tt "FUNC") ".") (p "Returns a partially curried procedure."))
(def (sig (procedure "(crop-left FUNC N) => procedure" (id crop-left))) (p "Returns a procedure that drops the " (tt "N") " left arguments before applying " (tt "FUNC") "."))
(def (sig (procedure "(crop-right FUNC N) => procedure" (id crop-right))) (p "Returns a procedure that drops the " (tt "N") " right arguments before applying " (tt "FUNC") "."))
(def (sig (procedure "(reversed FUNC) => procedure" (id reversed))) (p "Returns a procedure that reverses the arguments before applying " (tt "FUNC") "."))
(def (sig (procedure "(arguments-chain [FUNC0...]) => procedure" (id arguments-chain))) (p "Returns a procedure that applies each " (tt "FUNCi") " to result of the " (tt "FUNCi+1") ". " (tt "FUNCn") " is applied to the arguments.") (p "Examples:") (pre "((arguments-chain f g h) arg...) -> (apply f (apply g (apply h arg...)))") (pre "((arguments-chain f) arg...) -> (apply f arg...)") (pre "((arguments-chain) arg...) -> (list arg...)"))
(def (sig (procedure "(arguments-each [FUNC0...]) => procedure" (id arguments-each))) (p "Returns a procedure that calls each " (tt "FUNCi") " to the " (tt "ARGi") ". The result is returned as a " (tt "list") ". The " (tt "FUNC0...") " are re-used until the argument list is exhausted.") (p "Examples:") (pre "((arguments-each f g h) a b c d e) -> (list (f a) (g b) (h c) (f d) (g e))") (pre "((arguments-each f g h) a b c) -> (list (f a) (g b) (h c))") (pre "((arguments-each) arg...) -> (list arg...)"))
(def (sig (procedure "(arguments-all [FUNC0...]) => procedure" (id arguments-all))) (p "Returns a procedure that calls each " (tt "FUNCi") " with all the arguments. The result is returned as a " (tt "list") ".") (p "Examples:") (pre "((arguments-all f g h) a b c) -> (list (f a b c) (g a b c) (h a b c))") (pre "((arguments-all) arg...) -> (list arg...)"))
(def (sig (procedure "(group-by FUNC [EQUALITY equal?]) => procedure" (id group-by))) (p "Returns a procedure that takes a list and groups the elements by some key attribute. Uses the single-argument " (tt "FUNC") " to retrieve key values & the " (tt "EQUALITY") " function to compare them."))
(def (sig (procedure "(group/key FUNC LYST [EQUALITY equal?])" (id group/key))) (p "Groups a " (tt "LYST") " of elements by some key attribute. Uses the single-argument " (tt "FUNC") " to retrieve key values & the " (tt "EQUALITY") " function to compare them.") (p "The " (tt "LYST") " must be in sorted order with respect to the key!") (p "Returns a list of grouped elements."))
(def (sig (procedure "(make-less-than/key FUNC [LESS-THAN <]) => {{procedure/2}}" (id make-less-than/key))) (p "Returns a two-argument procedure that uses the single-argument " (tt "FUNC") " to retrieve key values & the two-argument " (tt "LESS-THAN") " procedure to compare them."))
(def (sig (procedure "(make-equal/key FUNC [EQUAL =]) => {{procedure/2}}" (id make-equal/key))) (p "Returns a two-argument procedure that uses the single-argument " (tt "FUNC") " to retrieve key values & the two-argument " (tt "EQUAL") " procedure to compare them."))
(def (sig (procedure "(andf OBJECT...)" (id andf))) (p "Eager version of " (tt "and") ".") (p "Returns last " (tt "(not #f)") " " (tt "OBJECT") " when all " (tt "OBJECT...") " are " (tt "(not #f)") ", " (tt "#f") " otherwise."))
(def (sig (procedure "(orf OBJECT...)" (id orf))) (p "Eager version of " (tt "or") ".") (p "Returns first " (tt "(not #f)") " " (tt "OBJECT") ", " (tt "#f") " otherwise."))
(def (sig (procedure "(uni C F) => procedure" (id uni))) (p "Returns " (tt "(lambda (X) (C (F X)))") "."))
(def (sig (procedure "(uni2 C F) => procedure" (id uni2))) (p "Returns " (tt "(lambda (X Y) (C (F X Y)))") "."))
(def (sig (procedure "(uni3 C F) => procedure" (id uni3))) (p "Returns " (tt "(lambda (X Y Z) (C (F X Y Z)))") "."))
(def (sig (procedure "(uni-each C F) => procedure" (id uni-each))) (p "Same as " (tt "uni") "."))
(def (sig (procedure "(uni-all C F) => procedure" (id uni-all))) (p "Returns " (tt "(lambda XS (C (apply F XS)))") "."))
(def (sig (procedure "(bi C F G) => procedure" (id bi))) (p "Returns " (tt "(lambda (X) (C (F X) (G X)))") "."))
(def (sig (procedure "(bi2 C F G) => procedure" (id bi2))) (p "Returns " (tt "(lambda (X Y) (C (F X Y) (G X Y)))") "."))
(def (sig (procedure "(bi3 C F G) => procedure" (id bi3))) (p "Returns " (tt "(lambda (X Y Z) (C (F X Y Z) (G X Y Z)))") "."))
(def (sig (procedure "(bi-each C F) => procedure" (id bi-each))) (p "Returns " (tt "(lambda (X Y) (C (F X) (F Y)))") "."))
(def (sig (procedure "(bi-all C F G) => procedure" (id bi-all))) (p "Returns " (tt "(lambda XS (C (apply F XS) (apply G XS)))") "."))
(def (sig (procedure "(tri C F G H) => procedure" (id tri))) (p "Returns " (tt "(lambda (X) (C (F X) (G X) (H X)))") "."))
(def (sig (procedure "(tri2 C F G H) => procedure" (id tri2))) (p "Returns " (tt "(lambda (X Y) (C (F X Y) (G X Y) (H X Y)))") "."))
(def (sig (procedure "(tri3 C F G H) => procedure" (id tri3))) (p "Returns " (tt "(lambda (X Y Z) (C (F X Y Z) (G X Y Z) (H X Y Z)))") "."))
(def (sig (procedure "(tri-each C F) => procedure" (id tri-each))) (p "Returns " (tt "(lambda (X Y Z) (C (F X) (F Y) (F Z)))") "."))
(def (sig (procedure "(tri-all C F G H) => procedure" (id tri-all))) (p "Returns " (tt "(lambda XS (C (apply F XS) (apply G XS) (apply H XS)))") "."))
(def (sig (procedure "(uni X F C) => procedure" (id uni))) (p "Returns the result of " (tt "(C (F X))") "."))
(def (sig (procedure "(uni F C) => {{procedure/1}}" (id uni)) (procedure "(uni C) => {{procedure/1}}" (id uni)) (procedure "(uni) => {{procedure/1}}" (id uni))) (p "Returns a curried procedure."))
(def (sig (procedure "(uni2 X Y F C) => procedure" (id uni2))) (p "Returns the result of " (tt "(C (F X Y))") "."))
(def (sig (procedure "(uni2 F C) => {{procedure/2}}" (id uni2)) (procedure "(uni2 C) => {{procedure/1}}" (id uni2)) (procedure "(uni2) => {{procedure/1}}" (id uni2))) (p "Returns a curried procedure."))
(def (sig (procedure "(uni3 X Y Z F C) => procedure" (id uni3))) (p "Returns the result of " (tt "(C (F X Y Z))") "."))
(def (sig (procedure "(uni3 F C) => {{procedure/3}}" (id uni3)) (procedure "(uni3 C) => {{procedure/1}}" (id uni3)) (procedure "(uni3) => {{procedure/1}}" (id uni3))) (p "Returns a curried procedure."))
(def (sig (procedure "(uni@ X F C) => procedure" (id uni@))) (p "Returns the result of " (tt "(C (F X))") "."))
(def (sig (procedure "(uni@ F C) => {{procedure/1}}" (id uni@))) (p "Returns a curried procedure."))
(def (sig (procedure "(bi X F G C) => procedure" (id bi))) (p "Returns the result of " (tt "(C (F X) (G X))") "."))
(def (sig (procedure "(bi F G C) => {{procedure/1}}" (id bi)) (procedure "(bi F G) => {{procedure/1}}" (id bi)) (procedure "(bi C) => {{procedure/2}}" (id bi)) (procedure "(bi) => {{procedure/1}}" (id bi))) (p "Returns a curried procedure."))
(def (sig (procedure "(bi2 X Y F G C) => procedure" (id bi2))) (p "Returns the result of " (tt "(C (F X Y) (G X Y))") "."))
(def (sig (procedure "(bi2 F G C) => {{procedure/2}}" (id bi2)) (procedure "(bi2 F G) => {{procedure/1}}" (id bi2)) (procedure "(bi2 C) => {{procedure/2}}" (id bi2)) (procedure "(bi2) => {{procedure/1}}" (id bi2))) (p "Returns a curried procedure."))
(def (sig (procedure "(bi3 X Y Z F G C) => procedure" (id bi3))) (p "Returns the result of " (tt "(C (F X Y Z) (G X Y Z))") "."))
(def (sig (procedure "(bi3 F G C) => {{procedure/3}}" (id bi3)) (procedure "(bi3 F G) => {{procedure/1}}" (id bi3)) (procedure "(bi3 C) => {{procedure/2}}" (id bi3)) (procedure "(bi3) => {{procedure/1}}" (id bi3))) (p "Returns a curried procedure."))
(def (sig (procedure "(bi@ X Y F C) => procedure" (id bi@))) (p "Returns the result of " (tt "(C (F X) (F Y))") "."))
(def (sig (procedure "(bi@ F C) => {{procedure/2}}" (id bi@))) (p "Returns a curried procedure."))
(def (sig (procedure "(tri X F G H C) => procedure" (id tri))) (p "Returns the result of " (tt "(C (F X) (G X) (H X))") "."))
(def (sig (procedure "(tri F G H C) => {{procedure/1}}" (id tri)) (procedure "(tri F G H) => {{procedure/1}}" (id tri)) (procedure "(tri C) => {{procedure/3}}" (id tri)) (procedure "(tri) => {{procedure/1}}" (id tri))) (p "Returns a curried procedure."))
(def (sig (procedure "(tri2 X Y F G H C) => procedure" (id tri2))) (p "Returns the result of " (tt "(C (F X Y) (G X Y) (H X Y))") "."))
(def (sig (procedure "(tri2 F G H C) => {{procedure/2}}" (id tri2)) (procedure "(tri2 F G H) => {{procedure/1}}" (id tri2)) (procedure "(tri2 C) => {{procedure/3}}" (id tri2)) (procedure "(tri2) => {{procedure/1}}" (id tri2))) (p "Returns a curried procedure."))
(def (sig (procedure "(tri3 X Y Z F G H C) => procedure" (id tri3))) (p "Returns the result of " (tt "(C (F X Y Z) (G X Y Z) (H X Y Z))") "."))
(def (sig (procedure "(tri3 F G H C) => {{procedure/3}}" (id tri3)) (procedure "(tri3 F G H) => {{procedure/1}}" (id tri3)) (procedure "(tri3 C) => {{procedure/3}}" (id tri3)) (procedure "(tri3) => {{procedure/1}}" (id tri3))) (p "Returns a curried procedure."))
(def (sig (procedure "(tri@ X Y Z F C) => procedure" (id tri@))) (p "Returns the result of " (tt "(C (F X) (F Y) (F Z))") "."))
(def (sig (procedure "(tri@ F C) => {{procedure/3}}" (id tri@))) (p "Returns a curried procedure."))
(def (sig (procedure "(dip X Y F C) => procedure" (id dip))) (p "Returns the result of " (tt "(C (F X) Y)") "."))
(def (sig (procedure "(dip F C) => {{procedure/2}}" (id dip))) (p "Returns a curried procedure."))
(def (sig (procedure "(dup X C) => procedure" (id dup))) (p "Returns the result of " (tt "(C X X)") "."))
(def (sig (procedure "(dup C) => {{procedure/1}}" (id dup))) (p "Returns a curried procedure."))
(def (sig (procedure "(dupd X Y C) => procedure" (id dupd))) (p "Returns the result of " (tt "(C X X Y)") "."))
(def (sig (procedure "(dupd C) => {{procedure/2}}" (id dupd))) (p "Returns a curried procedure."))
(def (sig (procedure "(swap X Y C) => procedure" (id swap))) (p "Returns the result of " (tt "(C Y X)") "."))
(def (sig (procedure "(swap C) => {{procedure/2}}" (id swap))) (p "Returns a curried procedure."))
(def (sig (procedure "(drop X C) => procedure" (id drop))) (p "Returns the result of " (tt "(C)") "."))
(def (sig (procedure "(drop C) => {{procedure/1}}" (id drop))) (p "Returns a curried procedure."))
(def (sig (procedure "(drop/2 X Y C) => procedure" (id drop/2))) (p "Returns the result of " (tt "(C X)") "."))
(def (sig (procedure "(drop/2 C) => {{procedure/2}}" (id drop/2))) (p "Returns a curried procedure."))
