Next: , Previous: Statement-lifting, Up: Principles of Compilation

5.5 Higher-order Arglists

All procedures taking a list argument are converted into ordinary non-list taking procedures and they are called with the list-making calls inserted. For example,

     (define foo
       (lambda (x . y)
         (cons x (reverse y)) ))

is converted to

     (define foo
       (lambda (x y)
         (cons x (reverse y)) ))

and any call to foo will make a list for a variable y. For example,

     (foo 1 2 3)

is converted to

     (foo 1 (cons 2 (cons 3 '()))).

All higher-order procedure calls where an argument-term contains unbound variables will generate a new instance (provided it has not been created already) of this higher-order procedure, carrying the right amount of free variables inside to right places.

For example, if there is a following definition:

     (define (member-if fn lst)
        (if (fn (car lst))
            (member-if fn (cdr lst)) ))

and a call

     (member-if (lambda (x) (eq? x y)) lst),

a new instance of member-if is created (if an analogous one has not been created before):

     (define (member-if_inst1 tmp fn lst)
        (if (fn tmp (car lst))
            (member-if_inst1 tmp fn (cdr lst)) ))

and the call is converted to

     (member-if_inst1 y foo lst)

and a top-level define

     (define (foo y x) (eq? x y))

In addition, if the higher-order procedure is to be exported, an additional instance is created, which uses apply to call all argument-procedures, assuming they are defined via interpreter. The exportable higher-order procedure will have a name fun_exporthof, where fun is the name of the original procedure.