Runtime evaluation/In an environment: Difference between revisions

<!-- {{does not work with|ELLA ALGOL 68|Any This implementation is a compiler}} -->

Variable names are generally not visible at run time with classic compilers. However '''ALGOL 68G''' is an interpretor and it retains this ability. Note that ''evaluate'' returns a '''string'''.

(INT x=a; evaluate(code) ) + (INT x=b; evaluate(code));

print((eval_with_x("2 ** x", 3, 5), new line))</lang>

=={{header|Common Lisp}}==

 

(let ((at-a (eval `(let ((x ',a)) ,program)))

(at-b (eval `(let ((x ',b)) ,program))))

 

 

This version ensures that the program is compiled, once, for more efficient execution:

 

(let* ((f (compile nil `(lambda (x) ,program)))

(at-a (funcall f a))

(at-b (funcall f b)))

 

=={{header|E}}==

=={{header|Forth}}==

EVALUATE invokes the Forth interpreter on the given string.

[char] " parse ( code len )

2dup 2>r evaluate

- . ;

 

This can be used to treat a data stream as code, or to provide a lightweight macro facility when used in an IMMEDIATE word.

: [CHAR] ; PARSE POSTPONE SLITERAL POSTPONE EVALUATE

POSTPONE ; IMMEDIATE

DO .\" spam "

LOOP

 

=={{header|Genyris}}==

One way is to use a macro. In genyris, macros are lazy functions which execute twice, the return value is also evaluated in the caller's environment:

 

var x 23

Another way is to use dynamically scoped variables. In Genyris, symbols prefixed with a period are looked up in the caller's environment, not the lexical environment of the closure. When a dictionary is the first element of the expression, an environment is created and the &rest is evaluated.

 

 

(dict) # create an environment capable of holding dynamic bindings

+ firstresult (add100)</lang>

Dictionaries can hold bindings to dynamic symbols. To minimize the danger of dynamic scope there is no recursive ascent in the binding lookup.

var .x 23

(dict)

===Explicit===

The following satisfies the requirements:

'CODE V0 V1'=. y

(". CODE [ x=. V1) - (". CODE [ x=. V0)

EvalWithX '^x';0;1

===Tacit===

However, it is easier via point-free coding:

 

=={{header|JavaScript}}==

=={{header|TI-89 BASIC}}==

 

 

 

There are no facilities for control over the environment; expr() evaluates in the same environment as the caller, including local variables. [Someone please verify this statement.] [[Category:TI-89 BASIC examples needing attention]]