21. Bigloo
A ``practical Scheme compiler''
User manual for version 2.6e
October 2004 -- DSSSL support
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.

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

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





This Html page has been produced by Skribe.
Last update Tue Oct 19 12:32:21 2004.