Re: Anything better for delayed lexical evaluation than (lambda () ...)?

[David Kastrup]

Marco Maggi <address@hidden> writes:

> David Kastrup wrote:
>> Hi, if I have something  read that is evaluated later, the
>> lack  of procedure-environment in  Guilev2 implies  that I
>> have  to wrap the  stuff in  (lambda ()  ...) in  order to
>> capture the lexical environment for evaluation.
>
> Sorry to step in without  an answer.  What are you trying to
> do?  What I  understand is that a Scheme  program reads some
> expressions and tries to evaluate them in a specific context
> of the program.   Are you looking for a  way to do something
> like the following chunk I found on the Net?
>
> (define x 0)
> (define clo 
>   (let ((x 1)) 
>     (lambda () '())))
> (local-eval 'x (procedure-environment clo))
> => 1 

It is more like
(define (myeval what)
  (let* ((x 1)
         (clo (procedure-environment (lambda () #f))))
     (local-eval (read (open-input-string what)) clo)))

(myeval "(+ x 3)")

Basically a string evaluation of a string that will be captured with
read-hash-extend in our application.

In practice, _both_ the environment created by (let* ((x 1)) ...) as
well as the string to be interpreted later are written by the user, but
they are spliced together at quite different points of time since the
environment from which the string for myeval gets delivered is available
only when the definition is being executed, not yet at its definition
time.

Basically I need to evaluate dynamic code in a given lexical environment
rather than at top and/or module level.

For a language that is supposed to be a building block for extension
languages, not really a concept that is all that unusual I would think.

-- 
David Kastrup