| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
[R5RS] Evaluates to a procedure. The environment in effect when this expression is evaluated is stored in the procedure. When the procedure is called, body is evaluated sequentially in the stored environment extended by the bindings of the formal arguments, and returns the value(s) of the last expression in the body.
Formals should have one of the following forms:
(variable …) : The procedure takes a fixed number of
arguments. The actual arguments are bound to the corresponding
variables.
variable : The procedure takes any number of arguments.
The actual arguments are collected to form a new list and bound to
the variable.
(variable_0 … variable_N-1. variable_N) :
The procedure takes at least N arguments. The actual arguments
up to N is bound to the corresponding variables.
If more than N arguments are given, the rest arguments are
collected to form a new list and bound to variable_N.
(lambda (a b) (+ a b))
⇒ procedure that adds two arguments
((lambda (a b) (+ a b)) 1 2)
⇒ 3
|
Note: Some Scheme implementations extend the syntax of formals to have notation of optional arguments or keyword arguments, similar to CommonLisp's. Gauche doesn't have such extensions now.
[SRFI-26] Convenience macros to notate a procedure compactly. This form can be used to realize partial application, a.k.a sectioning or projection.
Each expr-or-slot must be either an expression or a symbol <>,
indicating a 'slot'.
The last expr-or-slot can be a symbol <...>,
indicating a 'rest-slot'.
Cut expands into a lambda form that takes as many arguments
as the number of slots in the given form, and
whose body is an expression
(expr-or-slot expr-or-slot2 …) |
where each occurrence of <> is replaced to the corresponding
argument.
In case there is a rest-slot symbol, the resulting procedure is also
of variable arity, and all the extra arguments are passed
to the call of expr-or-slot. See the fourth example below.
(cut cons (+ a 1) <>) ≡ (lambda (x2) (cons (+ a 1) x2)) (cut list 1 <> 3 <> 5) ≡ (lambda (x2 x4) (list 1 x2 3 x4 5)) (cut list) ≡ (lambda () (list)) (cut list 1 <> 3 <...>) ≡ (lambda (x2 . xs) (apply list 1 x2 3 xs)) (cut <> a b) ≡ (lambda (f) (f a b)) ;; Usage (map (cut * 2 <>) '(1 2 3 4)) (for-each (cut write <> port) exprs) |
Cute is a variation of cut that evaluates expr-or-slots
before creating the procedure.
(cute cons (+ a 1) <>) ≡ (let ((xa (+ a 1))) (lambda (x2) (cons xa x2))) |
Gauche also has a built-in procedure pa$ for partial application
(See section Combinators).
[SRFI-16]
Each clause should have the form (formals expr …),
where formals is a formal arguments list as for lambda.
This expression evaluates to a procedure that accepts a variable
number of arguments and is lexically scoped in the same manner as
procedures resulting from lambda expressions.
When the procedure is called with some arguments,
then the first clause for which the arguments agree with
formals is selected, where agreement is specified as for
the formals of a lambda expression.
The variables of formals are bound to the given
arguments, and the expr … are evaluated within the environment.
It is an error for the arguments not to agree with the formals of any clause.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] |
This document was generated by Shiro Kawai on October, 7 2008 using texi2html 1.78.