20.1 DSSSL formal argument lists
20.2 Modules and DSSSL formal argument lists
Copyright
Acknowledgements
1. Table of contents
2. Overview of Bigloo
3. Modules
4. Core Language
5. Standard Library
6. Pattern Matching
7. Object System
8. Threads
9. Regular parsing
10. Lalr(1) parsing
11. Errors and Assertions
12. Eval and code interpretation
13. Macro expansion
14. Command Line Parsing
15. Explicit typing
16. The C interface
17. The Java interface
18. Bigloo Libraries
19. SRFIs
20. DSSSL support
21. Compiler description
22. User Extensions
23. Bigloo Development Environment
24. Global Index
25. Library Index
Bibliography
|
Bigloo supports extensions for the Dsssl expression language
[Dsssl96]:
- Keywords. Bigloo supports full Dsssl keywords.
- Named constants. Bigloo implements the three Dsssl named constants:
#!optional , #!rest and #!key .
- Dsssl formal argument lists.
20.1 DSSSL formal argument lists
|
Dsssl formal argument lists are defined by the following grammar:
<formal-argument-list> ==> <required-formal-argument>*
[(#!optional <optional-formal-argument>*) ]
[(#!rest <rest-formal-argument>) ]
[(#!key <key-formal-argument>*) ]
<required-formal-argument> ==> <ident>
<optional-formal-argument> ==> <ident>
| ( <ident> <initializer>)
<rest-formal-argument> ==> <ident>
<key-formal-argument> ==> <ident>
| ( <ident> <initializer>)
<initializer> ==> <expr> |
When a procedure is applied to a list of actual arguments, the formal
and actual arguments are processed from left to right as follows:
- Variables in required-formal-arguments are bound
to successive actual arguments starting with the first actual
argument. It shall be an error if there are fewer actual arguments
than required-formal-arguments.
- Next, variables in optional-formal-arguments are bound to
any remaining actual arguments. If there are fewer remaining actual arguments
than optional-formal-arguments, then variables are bound to the
result of the evaluation of initializer, if one was specified, and
otherwise to
#f . The initializer is evaluated in an environment
in which all previous formal arguments have been bound.
- If there is a rest-formal-argument, then it is bound to a
list of all remaining actual arguments. The remaining actual
arguments are also eligible to be bound to keyword-formal-arguments.
If there is no rest-formal-argument and there are no
keyword-formal-arguments, the it shall be an error if there are any
remaining actual arguments.
- If
#!key was specified in the formal-argument-list,
there shall be an even number of remaining actual arguments. These are
interpreted as a series of pairs, where the first member of each pair
is a keyword specifying the argument name, and the second is the
corresponding value. It shall be an error if the first member of a
pair is not a keyword. It shall be an error if the argument name is not
the same as a variable in a keyword-formal-argument, unless there
is a rest-formal-argument. If the same argument name occurs
more than once in the list of actual arguments, then the first value
is used. If there is no actual argument for a particular
keyword-formal-argument, then the variable is bound to the result of
evaluating initializer if one was specified, and otherwise
#f . The initializer is evaluated in an environment in which all
previous formal arguments have been bound.
It shall be an error for an <ident> to appear more than once
in a formal-argument-list.
Example:
((lambda (x y) x) 3 4 5 6) =>(3 4 5 6)
((lambda (x y #!rest z) z)
3 4 5 6) => (5 6)
((lambda (x y #!optional z #!rest r #!key i (j 1))
(list x y z i: i j: j))
3 4 5 i: 6 i: 7) => (3 4 5 i: 6 j: 1)
|
20.2 Modules and DSSSL formal argument lists
|
Functions using Dsssl formal argument lists can be exported or
imported in the same way as all regular Bigloo functions. When
exporting such a Dsssl function, the named constants must be included
in the prototype of the function but the formal parameters are not
required. That is, for instance, the exportation prototype for the
function:
(define (foo x y #!optional z #!key i (j 1)) ...)
|
looks like:
(export (foo x y #!optional #!key))
|
|