For Gauche 0.9.15Search (procedure/syntax/module):

### 11.62 `srfi.235` - Combinators (SRFI)

Module: srfi.235

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
```

#### Combinator utilities

Procedures that takes procedure(s) and returns a procedure.

Function: on-left proc

[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
```
Function: on-right proc

[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
```
Function: conjoin pred …

[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
```
Function: disjoin pred …

[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
```
Function: each-of proc …

[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
```
Function: all-of pred

[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)
```
Function: any-of pred

[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)
```
Function: on reducer mapper

[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
```
Function: left-section proc arg …

[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)
```
Function: right-section proc arg …

[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 …)
```
Function: apply-chain proc proc2 …

[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)
```
Function: arguments-drop proc n
Function: arguments-drop-right proc n
Function: arguments-take proc n
Function: arguments-take-right proc n

[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)
```
Function: group-by key-proc :optional equal

[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"))
```

#### Syntax-like procedures

Function: begin-procedure thunk …

[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>`.

Function: if-procedure value then-thunk else-thunk

[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).

Function: when-procedure value thunk …
Function: unless-procedure value thunk …

[SRFI-235]{srfi.235} If value evaluates to true/false, calls each thunk in turn and returns an undefined value, respectively. Otherwise, returns imediately.

Function: value-procedure value then-proc else-thunk

[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).

Function: case-procedure value thunk-alist :optional else-thunk

[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が与えられていればそれが呼ばれてその結果が戻り値となり、 与えられていなければ未定義値が返されます。

Function: and-procedure 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`.

Function: eager-and-procedure thunk …

[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`.

Function: or-procedure thunk …

[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`.

Function: eager-or-procedure thunk …

[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`.

Function: funcall-procedure thunk

[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)`.

Function: loop-procedure thunk

[SRFI-235]{srfi.235} Calls thunk repeatedly forever. Nonlocal escape is the only way to break out.

Function: while-procedure thunk
Function: until-procedure thunk

[SRFI-235]{srfi.235} Calls thunk repeatedly while/until it returns a true value, respectively.

#### Auxiliary utilities

Function: always obj …

[SRFI-235]{srfi.235} Ignores arguments and always returns `#t`. Same as `(constantly #t)`.

Function: never obj …

[SRFI-235]{srfi.235} Ignores arguments and always returns `#f`. Same as `(constantly #f)`.

Note: `boolean` is provided in the core (see Booleans).

For Gauche 0.9.15Search (procedure/syntax/module):