srfi.235 - Combinators (SRFI) ¶This srfi provides combinator utilities. Gauche provides some frequently-used combinators built-in. This module augments it.
The following procedures are built-in; see Combinators, for the details.
constantly complement flip swap boolean
Procedures that takes procedure(s) and returns a procedure.
[SRFI-235]{srfi.235}
Returns a two argument procedure, which ignores its right argument
and calls proc with the left argument.
((on-left car) '(a b) '(c d)) ⇒ a
[SRFI-235]{srfi.235}
Returns a two argument procedure, which ignores its left argument
and calls proc with the right argument.
((on-right car) '(a b) '(c d)) ⇒ c
[SRFI-235]{srfi.235}
Returns a procedure taking any number of arguments and that behaves
as follows: For each argument, calls pred … left to right;
if any of pred returns #f, stop and immediately returns
#f. If all predicates returns a true value for all arguments,
returns the last result. If no preds are given, or no arguments are given,
returns #t.
((conjoin char? digit->integer) #\1 #\2 #\3) ⇒ 3 ((conjoin char? digit->integer) #\1 #\a #\3) ⇒ #f
[SRFI-235]{srfi.235}
Returns a procedure taking any number of arguments and that behaves
as follows: For each argument, calls pred … left to right;
if any of pred returns a true value, stop and immediately returns
that value. If all predicates returns #f for all arguments,
returns #f. If no preds are given, or no arguments are given,
returns #f.
((disjoin integer? char?) 'a 'b 'c) ⇒ #f ((disjoin integer? char?) #\a 'b 'c) ⇒ #t
[SRFI-235]{srfi.235}
Returns a procedure that works, when applied to arguments, applies
each proc on the arguments in turn. The result of
procs are discarded.
(define (f x y) (print (+ x y))) (define (g x y) (print (* x y))) ((each-of f g) 2 7) ⇒ #<undef>; prints 9 and 14
[SRFI-235]{srfi.235}
Returns a procedure that takes one argument, a list.
The returned procedure tries to apply pred to each element
of list in turn.
If pred returns #f, immediately returns #f. Otherwise,
returns the last result of pred. If the returned procedure
is applied to an empty list, #t is returned.
The following equivalence holds:
((all-of pred) list) ≡ (every pred list)
[SRFI-235]{srfi.235}
Returns a procedure that takes one argument, a list.
The returned procedure applies pred to each element
of list in turn.
If pred returns a true value, immediately returns it. Otherwise,
returns #f. If the returned procedure
is applied to an empty list, #f is returned.
The following equivalence holds:
((any-of pred) list) ≡ (any pred list)
[SRFI-235]{srfi.235}
Returns a procedure such that (apply (on reducer mapper) args)
works as if (apply reducer (map mapper args)).
(define square-sum (on + square)) (square-sum 1 2 3 4 5) ⇒ 55
[SRFI-235]{srfi.235}
Returns a procedure such that, when applied to more args, calls proc
with arg … and the given args. In other words,
returns a specialized procedure with the left argumen(s) are given
as arg ….
In Gauche, this is the same as (pa$ arg …) (see Combinators).
((left-section list 'a 'b 'c) 'd 'e 'f) ⇒ (a b c d e f)
[SRFI-235]{srfi.235}
Returns a procedure such that, when applied to more args, calls proc
with the newly given args concatenated with (reverse arg …).
((right-section list 'a 'b 'c) 'd 'e 'f) ⇒ (d e f c b a)
The reason that arg … is reversed is because of this invariance:
(right-section proc arg arg1 ...) ≡ (right-section (right-section proc arg) arg1 ...)
[SRFI-235]{srfi.235}
Returns a procedure such that it applies the last procedure to the
given arguments, then applies the previous procedure on the
returned value(s), and so on. Returns the result(s) of proc.
((apply-chain car cdr) '(a b c d)) ⇒ b ((apply-chain list div-and-mod) 10 3) ⇒ (3 1)
[SRFI-235]{srfi.235}
Returns a procedure such that proc is applied on the argument
list after taking/dropping n arguments. That is,
(arguments-drop proc n) is
(^ args (apply proc (drop args n))), and so on.
((arguments-drop list 2) 'a 'b 'c 'd 'e) ⇒ (c d e) ((arguments-drop-right list 2) 'a 'b 'c 'd 'e) ⇒ (a b c) ((arguments-take list 2) 'a 'b 'c 'd 'e) ⇒ (a b) ((arguments-take-right list 2) 'a 'b 'c 'd 'e) ⇒ (d e)
[SRFI-235]{srfi.235}
Returns a procedure that takes one list argument. It applies
key-proc to each element of the list to get keys, and then
elements with the same key are grouped into a fresh list, and
returns list of such groups.
The keys are compared with equal, which defaults to equal?.
Within each group, elements that appears left in the original list
also appears on the left.
((group-by key-proc eq-proc) lis) works like
(group-collection lis :key key-proc :test eq-proc), except
that group-collection can take any collection
(see Selection and searching in collection).
((group-by (cut string-ref <> 0) char-ci=?)
'("apricot" "Banana" "Apple" "blueberry"))
⇒ (("apricot" "Apple") ("Banana" "blueberry"))
[SRFI-235]{srfi.235}
Calls thunk … from left to right. Discats their results
except the last one(s), which will be the result(s) of this procedure.
If no thunks are given, returns #<undef>.
[SRFI-235]{srfi.235}
If value is true, calls then-thunk and returns its
result(s). Otherwise, calls else-thunk and returns its result(s).
[SRFI-235]{srfi.235}
If value evaluates to true/false, calls each thunk in turn
and returns an undefined value, respectively.
Otherwise, returns imediately.
[SRFI-235]{srfi.235}
If value evaluates to true, apply then-proc on it and returns
its result(s). Otherwise, call else-thunk and returns
its result(s).
[SRFI-235]{srfi.235}
The thunk-alist argument is a list of pairs of a value and
a thunk. First, value is evaluated, then the result
is searched from the cars of thunk-alist, using eqv?.
If there’s a matching entry, its thunk is called and its result(s) is/are
returned. If there’s no matching entry, else-thunk is invoked
if present and its result(s) is/are returned.
If there’s neither else-thunk, an undefined value is returned.
thunk-alist引数は、値とサンクのペアのリストです。
まずvalueが評価され、その値がthunk-alist中のペアのcarの値と順にeqv?
で比較されます。一致するエントリが見つかったら、そのペアのcdrにあるサンクが呼ばれ、
その結果が戻り値となります。一致するエントリが無い場合、
else-thunkが与えられていればそれが呼ばれてその結果が戻り値となり、
与えられていなければ未定義値が返されます。
[SRFI-235]{srfi.235}
Calls thunk … left to right, until it yields
#f, and returns #f. If all thunks yields
true value, returns the result of the last thunk.
If no thunks are given, returns #t.
[SRFI-235]{srfi.235}
Calls all thunks, then checks their results. If any
of the result is #f, returns #f.
Otherwise, returns the last result of thunk.
If no thunks are given, returns #t.
[SRFI-235]{srfi.235}
Calls thunk … left to right, until it yields
a true value, and returns that value. If all thunks yields
#f, returns #f. If no thunks are given,
returns #t.
[SRFI-235]{srfi.235}
Calls all thunks, then checks their results from left to right,
and returns the first true value. If all the results are #f,
or no thunks are given, returns #f.
[SRFI-235]{srfi.235}
Just call thunk and returns its result(s).
This is useful to pass to other procedures, e.g.
(map funcall-procedure list-of-procedures).
[SRFI-235]{srfi.235}
Calls thunk repeatedly forever. Nonlocal escape is the only
way to break out.
[SRFI-235]{srfi.235}
Calls thunk repeatedly while/until it returns a true value,
respectively.
[SRFI-235]{srfi.235}
Ignores arguments and always returns #t.
Same as (constantly #t).
[SRFI-235]{srfi.235}
Ignores arguments and always returns #f.
Same as (constantly #f).
Note: boolean is provided in the core (see Booleans).