Syntax: cut
slot-or-expr
slot-or-expr*
[<...>
]
where each
slot-or-expr
is either anexpression
or the literal symbol<>
.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 as partial application, operator section, or projection. The macrocut
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 alambda expression
with as many formal variables as there are slots in the listslot-or-expr
*. The body of the resultinglambda expression
calls the firstslot-or-expr
with arguments from theslot-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 firstslot-or-expr
with remaining arguments provided to the actual call of the specialized procedure.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 tocut
, 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 thecut
-variant will evaluate it during every invocation of the resulting procedure.