hello,
I want to make a portable module system using lexical scoping (1).
By using a letrec form, one can write
(define my-module
(lambda ()
(letrec ((private-fun (lambda () ..))
(public-fun (lambda () ..)))
(list 'public-fun public-fun))))
I use the let () form wich I believe is equivalent :
(define my-module
(lambda ()
(let ()
(define private-fun
(lambda () ..))
(define public-fun (lambda () ..))
(list 'public-fun public-fun))))
But I have an annoying limitation with letrec.
For letrec, each init expression must evaluate without referencing or assigning the value of any of the vars.
That is a problem when I want this code to be encapsulated in a module :
(define private-fun (lambda (x) ...)
(define public-var (private-fun 'a-value))
by putting these expression into a let () form violate the scheme rules (2)
The letrec* macro does exactly what I want, unfortunately it is not available in a r5rs system as gambit-c
The solution I see is tracking the backward references to variables or functions declared earlier and add a new closure each time a reference is made.
The preceding code would be translated by :
(define my-module
(lambda ()
(let ()
(define private-fun (lambda (x) ..))
(let ()
(define public-var (private-fun 'a-value))
(list 'public-var public-var)))))
Is it the best strategy to deal with this problem ?
Does the letrec* macro can be written for gambit-c ?
thanks
cyrille
references :