Syntax: `cut`

`slot-or-expr`

* slot-or-expr** [

`<...>`

where each

is either an`slot-or-expr`

or the literal symbol`expression`

`<>`

.It is frequently necessary to specialize some of the parameters of a multi-parameter procedure. For example, from the binary operation

`cons`

one might want to obtain the unary operation`(lambda (x) (cons 1 x))`

. This specialization of parameters is also known aspartial application,operator section, orprojection. The macro`cut`

specializes some of the parameters of its first argument. The parameters that are to show up as formal variables of the result are indicated by the symbol`<>`

, pronouced as "slot". In addition, the symbol`<...>`

, pronounced as "rest-slot", matches all residual arguments of a variable argument procedure.A

`cut`

-expression is transformed into awith as many formal variables as there are slots in the list`lambda expression`

*. The body of the resulting`slot-or-expr`

calls the first`lambda expression`

with arguments from the`slot-or-expr`

* list in the order they appear. In case there is a rest-slot symbol, the resulting procedure is also of variable arity, and the body calls the first`slot-or-expr`

with remaining arguments provided to the actual call of the specialized procedure.`slot-or-expr`

Here are some examples:

`(cut cons (+ a 1) <>)`

is the same as`(lambda (x2) (cons (+ a 1) x2))`

`(cut list 1 <> 3 <> 5)`

is the same as`(lambda (x2 x4) (list 1 x2 3 x4 5))`

`(cut list)`

is the same as`(lambda () (list))`

`(cut list 1 <> 3 <...>)`

is the same as`(lambda (x2 . xs) (apply list 1 x2 3 xs))`

The first argument can also be a slot, as one should expect in Scheme:

`(cut <> a b)`

is the same as`(lambda (f) (f a b))`

Syntax: `cute`

`slot-or-expr`

* slot-or-expr** [

`<...>`

The macro

`cute`

(a mnemonic for "cut with evaluated non-slots") is similar to`cut`

, but it evaluates the non-slot expressions at the time the procedure is specialized, not at the time the specialized procedure is called.For example

`(cute cons (+ a 1) <>)`

is the same as`(let ((a1 (+ a 1))) (lambda (x2) (cons a1 x2)))`

As you see from comparing this example with the first example above, the

`cute`

-variant will evaluate`(+ a 1)`

once, while the`cut`

-variant will evaluate it during every invocation of the resulting procedure.