Re: scm_* API extension? [was] scm_* API question

[Rob Browning]

address@hidden writes:

>  GuileBind a-symbol '(arbitrary (guile data) structure)

> i.e. i want guile to 'read' from the configuration file and bind
> 'a-symbol' to whatever was read. As a side note: as a quick hack i
> put the symbol into the module but i'd rather like to use something
> like an environment i can set up myself (i hope setting up an
> environment isn't to expensive performance wise), but i have way too
> little understanding about how to do this right now.  But it would
> make a _way_ cool web environment -- full control over the env.
> means secure execution as well as probably some nice passing on of
> context.

You may want to look at ice-9/safe.scm and ice-9/safe-r5rs.scm.  You
can see how to at least create your own anonymous modules:

  (use-modules (ice-9 safe))
  (define my-module (make-safe-module))

  (eval 'car my-module)
  #<primitive-procedure car>

or if you want an even more limited envt:

  (use-modules (ice-9 safe-r5rs))
  (define my-module (null-environment 5))

  (eval 'if my-module)
  #<primitive-macro! if>
  (eval 'car my-module)
  ABORT: (unbound-variable)

and then:

  (module-define! my-module 'my-func (lambda (x) x))

etc.  There's also a module-ref function and a module-use! function...

> BTW, one reasons i do use the module system is the impicit cacheing
> i get: a module gets loaded only once, and that does make a
> difference in response time compared to the initial 'eval a file per
> request' aproach of mod_guile.

Well that may or may not be the right thing to do if you're *just*
using the module system for the caching.  In that case, you may be
better off to implement the caching yourself (via a hash table or
whatever) and leave the module system to more static modules.

For example, depending on what you're wanting to do, you might want to
allow different requests to be handled inside separate namespaces,
though they're all using a common set of code.  OTTOMH, I think you
could do this by putting the common functionality into a module, say
foo.scm, then doing something like this for *each* request:

  (use-modules (foo))
  (define foo-module (resolve-module '(foo)))

  ;; For each request...
  (define next-request-envt (make-safe-module))
  (module-use! next-request-envt (module-public-interface foo-module))
  (define request-form (list handler-sym current-url-string))
  (eval request-form next-request-envt)

Marius, etc.  Please correct any inaccuracies above -- I'm just going
from what I've gathered while poking around.  I suspect we need more
thorough documentation of the acceptable usage of the anonymous module
stuff.

-- 
Rob Browning
rlb @defaultvalue.org, @linuxdevel.com, and @debian.org
Previously @cs.utexas.edu
GPG=1C58 8B2C FB5E 3F64 EA5C  64AE 78FE E5FE F0CB A0AD