[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: load in environment
Re: load in environment
Mon, 09 Jul 2007 13:22:05 -0400
Thunderbird 188.8.131.52 (X11/20070604)
What does PURIFY-MODULE! actually do? The docstring is just almost
clear enough for me to understand its purpose.
`purify-module!' is a procedure in the (guile) module.
Removes bindings in MODULE which are inherited from the (guile) module.
I think the mechanics of what it does are clear enough, but from my
understanding of modules, it seems essentially useless. MAKE-MODULE
returns an empty module with no bindings, which inherits from no other
module. Calling PURIFY-MODULE! on such an empty module would thus be a
no-op. The only reason that a module would inherit any bindings from
the (guile) module would be if it used (via MODULE-USE! or some such)
the guile module, whether directly, or via another module. So, if you
want a module which does not inherit any bindings from (guile), then it
seems the solution would be to simply not have your module use (guile),
or any module which uses (guile). I suppose that if you used a module
which used (guile), that it might be of some use, but presumably, the
module that uses (guile) does so for a reason, and removing those
bindings might cause it to stop working, in which case using that module
at all would be pointless. Clearly I've misunderstood something or other.
Your assessment of the situation seems to be correct. I have a
Scheme-like declarative ASL.
Is there any reason why you chose to read and eval the file manually
rather than using LOAD with the current module set to asl-interp?
Finally, I'd like to allow the user to generate the declarations in the
ASL programmatically. Naturally, this requires adding things like
lambda and + and stuff into asl-interp. How can I evaluate the safety
of various things I might add in? I'd even somewhat like to allow LOAD,
so that the ASL declarations could be split out into multiple files if
the user wanted.
Marco Maggi wrote:
"Jon Wilson" wrote:
I'm writing a function to load up some data from a file and
stick it in a hash table.
Lemmesee if I get it:
1. data representation is stored in a file;
2. the representation format is an Application Specific
Language (ASL), so the file is really a script in ASL;
3. ASL happens to be Scheme-like;
4. to convert the file representation in a process's
internal representation the script must be evaluatd in an
5. nobody wants the ASL script to mess with the process'
state or, worst, mess with the file system, etc;
this can be done using pure modules.
(use-modules (ice-9 rdelim))
(define (make-asl-interp funcs)
(let ((asl-interp (make-module)))
(for-each (lambda (p)
(module-define! asl-interp (car p) (cdr p)))
(define (asl-eval file-name)
(let* ((data-table (make-hash-table))
(item (lambda (name text number)
(hash-set! data-table name
(make-item text number))))
(asl-interp (make-asl-interp (list
(cons 'item item)))))
(eval-string (read-delimited "") asl-interp)))
(define make-item list)
(define table (asl-eval "data.asl"))
(format #t "dumping table:~%")
(hash-for-each (lambda (key val)
(format #t "~/key ~S, val ~S~%" key val))