Another useful facility is the ability to in-line code procedure definitions. In fact, the compiler will perform full beta conversion, with automatic renaming, if you request it. Here are the relevant declarations:
The variables names must be defined in the same file as this declaration. Any reference to one of the named variables that appears in the same block as the declaration, or one of its descendant blocks, will be replaced by the corresponding binding’s value expression.
Similar to the
integrate declaration, except that it only
substitutes for references that appear in the operator position of a
combination. All other references are ignored.
Causes the compiler to use the top-level integrations provided by filename. filename should not specify a file type, and the source-code file that it names must have been previously processed by the compiler.
If filename is a relative filename (the normal case), it is interpreted as being relative to the file in which the declaration appears. Thus if the declaration appears in file /usr/cph/foo.scm, then the compiler looks for a file called /usr/cph/filename.ext.
Note: When the compiler finds top-level integrations, it collects them
and outputs them into an auxiliary file with extension .ext.
This .ext file is what the
Note that the most common use of this facility, in-line coding of
procedure definitions, requires a somewhat complicated use of these
declarations. Because this is so common, there is a special form,
define-integrable, which is like
define but performs the
appropriate declarations. For example:
(define-integrable (foo-bar foo bar) (vector-ref (vector-ref foo bar) 3))
Here is how you do the same thing without this special form: there
should be an
integrate-operator declaration for the procedure’s
name, and (internal to the procedure’s definition) an
declaration for each of the procedure’s parameters, like this:
(declare (integrate-operator foo-bar)) (define (foo-bar foo bar) (declare (integrate foo bar)) (vector-ref (vector-ref foo bar) 3))
The reason for this complication is as follows: the
integrate-operator declaration finds all the references to
foo-bar and replaces them with the lambda expression from the
definition. Then, the
integrate declarations take effect because
the combination in which the reference to
supplies code that is substituted throughout the body of the procedure
definition. For example:
(foo-bar (car baz) (cdr baz))
First use the
((lambda (foo bar) (declare (integrate foo bar)) (vector-ref (vector-ref foo bar) 3)) (car baz) (cdr baz))
Next use the internal
((lambda (foo bar) (vector-ref (vector-ref (car baz) (cdr baz)) 3)) (car baz) (cdr baz))
Next notice that the variables
bar are not used,
and eliminate them:
((lambda () (vector-ref (vector-ref (car baz) (cdr baz)) 3)))
Finally, remove the ‘((lambda () …))’ to produce
(vector-ref (vector-ref (car baz) (cdr baz)) 3)
To see the effect of integration declarations (and of macros) on a source file, pretty-print the .bin file like this (be prepared for a lot of output).
(sf "foo.scm") (pp (fasload "foo.bin"))