Re: `undefine'

[Jost Boekemeier <jostobfe@calvados.zrz.TU-Berlin.DE>]

"Marisha Ray & Neil Jerram" <mpriz@dircon.co.uk> writes:


> It feels like it would be easy to implement any module system - including
> the existing module interface - on top of these spaces.  

Yep.  If you want to contribute, you can grab the environment implementation
and try to create a simple module system on top of it.

Create a module and a package environment first.  They map symbol names
to packages and modules.

(define package-environment (make-finite-environment))
(define module-environment (make-finite-environment))


After that create the appropriate data structures. For example:
package: (list-of-modules . EOL)
module: (vector    eval              exported protected belongs-to)
                   |   |                 |        |         |
                local imported          eval    eval     package
                       |    |
               import-list  lookup-proc(env, sym, import-list)
                   |
            (list of modules or export-environments)

eval:		eval-environment
exported:	export-environment
protected:	export-environment
belongs-to:	package
local:		finite-environment
imported:	import-list, lookup-proc(env, sym, import-list)


You create a new module as follows:

(define make-module 
  (lambda (package)
    (let* ((local (make-finite-environment))
	  (import (make-import-environment #f #f))
	  (export (make-export-environment local #f))
	  (protect (make-export-environment local #f))
	  (eval (make-eval-environment local import)))
      (vector eval export protect package))))


Module-define would read as follows:

(define module-define
  (lambda (package-sym module-sym)
    (let* ((package (environment-bound? package-environment package-sym))
	   (module (environment-bound? package-environment module-sym)))
      (if package
	  (let* ((module-list (car package)))
	    (if (not (and module (memq module module-list)))
		(let ((module (make-module package)))
		  (setcar! package (cons module module-list))
		  (set! the-module module)
		  (ge (module-eval-environment module)))))
	  (begin
	    (and module (error "internal error, module exists" module))
	    (let* ((package (cons #f '()))
		   (module (make-module package)))
	      (setcar! package (list module))
	      (environment-define package-environment package-sym package)
	      (environment-define module-environment module-sym module)
	      (set! the-module module)
	      (ge (module-eval-environment module))))))))


etc etc. ...



Jost