Runtime evaluation/In an environment: Difference between revisions

{{task}} Given a program in the language (as a string or AST) with a free variable named <var>x</var> (or another name if that is not valid syntax), evaluate it with <var>x</var> bound to a provided value, then evaluate it again with <var>x</var> bound to another provided value, then subtract the result of the first from the second and return or print it.

 

Do so in a way which:

* is plausibly extensible to a runtime-chosen set of bindings rather than just <var>x</var>

* does not make <var>x</var> a ''global'' variable

or note that these are impossible.

 

* For more general examples and language-specific details, see [[Eval]].

* [[Dynamic variable names]] is a similar task.

 

=={{header|ALGOL 68}}==

<!-- {{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));

Output:

<pre>

+8 +32

</pre>

=={{header|AutoHotkey}}==

{{works with | AutoHotkey_H}}

 

AutoHotkey does not provide an API to the local symbol table. Local variables are also not supported within scopes outside functions. However, a local environment can be simulated by wrapping code in a temporary function.

msgbox % second := evalWithX("x + 4", 6)

msgbox % second - first

if fnp := FindFunc(funcName)

numput(&x%newname%, fnp+0, 0, "uint")

 

=={{header|BBC BASIC}}==

one = FN_eval_with_x(expression$, 1.2)

two = FN_eval_with_x(expression$, 3.4)

DEF FN_eval_with_x(expr$, x)

 

=={{header|Bracmat}}==

= code a b argument

. !arg:((=?code),?a,?b,?argument)

& out$(eval-with-x$((='(.$x^!arg)),3,5,2))

& out$(eval-with-x$((='(.$x^!arg)),12,13,2))

Output:

<pre>16

 

We must define x as global, but we use dynamic bindings. Only functions within the binding will see the newly bound value of x, before it re-establishes the bindings that existed before.

 

(defn eval-with-x [program a b]

(- (binding [x b] (eval program))

 

 

 

=={{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|Déjà Vu}}==

if <= n 1:

n

!run-blob-in { :fib @fib :x 4 } code

!run-blob-in { :fib @fib :x 6 } code

{{out}}

<pre>5</pre>

 

=={{header|E}}==

#for historical reasons which will hopefully be entirely eliminated soon.

def bindX(value) {

def atB := program.eval(bindX(b))

return atB - atA

 

 

=={{header|EchoLisp}}==

We evaluate prog in a new environment which is an association list ((x x-value)), and could be ((x x-value) (y y-value)....)

(define (eval-with-x prog x)

(eval prog (environment-new (list (list 'x x)))))

x

😖️ error: #|user| : unbound variable : x

 

=={{header|Erlang}}==

Functions below are used by [[Dynamic_variable_names#Erlang| dynamic variable names]]. Any changes here needs to be backwards compatible, or [[Dynamic_variable_names#Erlang| dynamic variable names]] must also be changed.

-module( runtime_evaluation ).

 

io:fwrite( "~p~n", [Variable2] ),

io:fwrite( "~p~n", [Variable2 - Variable1] ).

 

{{out}}

1

</pre>

 

=={{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

x = 1000

print

 

This prints 1223.

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

.x = 1000

print

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)

=={{header|Go}}==

 

import (

func (v *intV) Assign(t *eval.Thread, o eval.Value) {

*v = intV(o.(eval.IntValue).Get(t))

Output:

<pre>

 

The solution:

Eval.x(x1, program) - Eval.x(x2, program)

 

Test Program:

x < 1 ? 0 : x == 1 ? 1 : (2..x).inject([0,1]){i, j -> [i[1], i[0]+i[1]]}[1]

'''

 

 

Output:

===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:

 

===Explicit again===

 

Or, using y as the free variable, instead of x:

-~/verb def x"_1 y

 

Example use:

 

 

This can be extended to support a user declared argument name:

 

:

-~/m adverb def ('(m)=.y';x)"_1 y

 

This works by preceding the user provided expression with a statement which assigns the argument value to a local variable whose name was provided by the user. [Note that this implementation skirts the requirement that the implementation does not manipulate strings -- instead we manipulate a structure containing strings.]

Example use:

 

1.71828

'Z + 2^Z' 'Z' EvalDiffWithName 2 3

 

Of course this could be re-defined such that the free variable declaration appears to the left of the expression (<code>'Z' 'Z + 2^Z' Example 2 3</code>). However, J's [[currying]] and precedence rules might make that less convenient to use, if this were ever used in a real program.

* the exception handling is minimal, but if something goes wrong you should get a stack dump and the exception ''might'' be helpful...

 

import java.lang.reflect.Method;

import java.net.URI;

);

}

 

Example usage - calculating the difference of two squares (i.e. 9 - 2 = 7):

eval uses the environment from the calling function.

 

var x = a;

var atA = eval(expr);

var atB = eval(expr);

return atB - atA;

 

 

=={{header|Liberty BASIC}}==

expression$ = "x^2 - 7"

Function EvaluateWithX(expression$, x)

EvaluateWithX = Eval(expression$)

 

=={{header|Lua}}==

code = loadstring"return x^2" --this doesn't really need to be input, does it?

val1 = setfenv(code, {x = io.read() + 0})()

val2 = setfenv(code, {x = io.read() + 0})()

print(val2 - val1)

 

In Lua 5.2 one can use the new <code>load</code> function to evaluate a string as Lua code and specify its environment:

{{works with|Lua|5.2}}

 

f = load("return x", nil, nil, env)

env.x = tonumber(io.read()) -- user enters 2

env.x = tonumber(io.read()) -- user enters 3

b = f()

 

(10 x /. x -> 3 ) - (10 x /. x -> 2 )

 

=={{header|MATLAB}} / {{header|Octave}}==

In Octave, undeclared variables are local.

 

x = val1;

a = eval(f);

b = eval(f);

r = b-a;

Usage:

<pre>p = 'x .* 2';

=={{header|Metafont}}==

 

save x,a,b; x := va; a := scantokens s;

x := vb; b := scantokens s; a-b

 

show(evalit("2x+1", 5, 3));

 

=={{header|ooRexx}}==

The ooRexx interpret instruction executes dynamically created ooRexx code in the current variable context.

say evalWithX("x**2", 2)

say evalWithX("x**2", 3.1415926)

-- X now has the value of the second argument

interpret "return" expression

Output:

<pre>

 

=={{header|Oz}}==

fun {EvalWithX Program A B}

{Compiler.evalExpression Program env('X':B) _}

end

in

 

=={{header|PARI/GP}}==

There are many ways of doing this depending on the particular interpretation of the requirements. This code assumes that <var>f</var> is a string representing a GP closure.

 

=={{header|Perl}}==

 

{my $code = shift;

my $x = shift;

return eval($code) - $first;}

 

 

=={{header|PHP}}==

 

function eval_with_x($code, $a, $b) {

$x = $a;

echo eval_with_x('return 3 * $x;', 5, 10), "\n"; # Prints "15".

 

=={{header|PicoLisp}}==

(println

(+

(+

(Function 3)

Output:

<pre>32

=={{header|Pike}}==

Pike can only compile complete classes. therefore binding a value to a variable is only possible by string manipulation. even Pikes own interactive mode which seemingly evaluates expressions wraps them into a class and replaces variable references before compiling:

Result: 10

> x * 5;

003: mixed ___HilfeWrapper() { return (([mapping(string:int)](mixed)___hilfe)->x) * 5; ; }

004:

___Hilfe is an object which stores all created variables;

 

to solve the problem in the task i would create a function that can take arguments:

 

program demo = compile_string("string eval(mixed x){ " + payload + "; }");

Result: 50

demo()->eval(20);

 

=={{header|Python}}==

 

return eval(code, {'x':b}) - eval(code, {'x':a})

 

>>> eval_with_x('2 ** x', 3, 5)

 

A slight change allows the evaluation to take multiple names:

return eval(code, kwordargs)

 

>>> code = '3 * x + y'

>>> eval_with_args(code, x=5, y=2) - eval_with_args(code, x=3, y=1)

 

=={{header|R}}==

We can set up thing so that the "unbound" variable can be any accepted symbol for variables.

env <- new.env() # provide a separate env, so that the choosen

assign(var, a, envir=env) # var name do not collide with symbols inside

print(evalWithAB("2*x+1", "x", 5, 3))

print(evalWithAB("2*y+1", "y", 5, 3))

 

=={{header|Racket}}==

 

Same hack as the on in the CL/Scheme entries:

#lang racket

(define ns (make-base-namespace))

(define (with v) (eval `(let ([x ',v]) ,code) ns))

(- (with b) (with a)))

 

Better: a more direct use of eval with just the code (for example, this

won't break if we use a namespace with a different meaning for

<tt>let</tt>, which is very possible in Racket):

#lang racket

(define ns (make-base-namespace))

(eval code ns))

(- (with b) (with a)))

 

=={{header|REBOL}}==

fn: func [x] [do bind prog 'x]

a: fn 2

b: fn 4

 

Result:

 

=={{header|REXX}}==

 

 

<pre>

</pre>

 

=={{header|Ring}}==

expression = "return pow(x,2) - 7"

one = evalwithx(expression, 1.2)

func evalwithx expr, x

return eval(expr)

Output:

<pre>

one = -5.56

two = 4.56

</pre>

 

=={{header|Ruby}}==

binding

end

end

 

 

The magic here is how the <code>binding</code> method works with the <code>bind_x_to_value(x)</code> method.

The <code>binding</code> method then returns a reference to the current context (or stack frame) to the caller.

<code>eval</code> can then use the local variable <code>x</code> in this context.

 

=={{header|Scheme}}==

Almost identical to the [[Common Lisp]] version above.

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

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

 

=={{header|Sidef}}==

var f = eval(code);

x = y;

}

 

 

=={{header|SNOBOL4}}==

This program defines (at runtime) a function triple(), compiles it, and then executes it twice, with values x = 1 and then x = 3. The program subtracts the returned value from the first call from the value returned from the first call, and prints the result. In this example, the value x is passed as a parameter to the function triple().

 

a x = 1

first = triple(x)

x = 3

output = triple(x) - first

 

Output:

If you specifically wanted to not pass x as a parameter but instead use it as a value from the environment, that's easy too:

 

a x = 1

first = triple(x)

x = 3

output = triple(x) - first

 

The output is the same.

 

=={{header|Tcl}}==

set x $a

set 1st [expr $func]

}

 

 

Here's another take, similar to other answers. It passes a code block to be <code>eval</code>ed, not just an expression for <code>expr</code>

expr {[set x $val2; eval $code] - [set x $val1; eval $code]}

}

 

In 8.5, <tt>apply</tt> makes environments like this "first class":

 

{{works with|Tcl|8.5}}

proc eval_with {body a b} {

set lambda [list x $body]

}

 

 

=={{header|TXR}}==

In TXR's embedded Lisp dialect, we can implement the same solution as Lisp or Scheme: transform the code fragment by wrapping a <code>let</code> around it which binds a variable, and then evaluating the whole thing:

 

(- (eval ^(let ((x ,x1)) ,code-fragment))

(eval ^(let ((x ,x0)) ,code-fragment))))

 

 

Cutting edge TXR code provides access to the environment manipulation functions, making this possible:

 

(let ((e1 (make-env (list (cons 'x x1)))) ;; create two environments stuffed with binding for x

(e0 (make-env (list (cons 'x x0)))))

(eval code-fragment e0))))

 

Alternatively, empty environments can be made and extended with bindings:

 

(let ((e1 (make-env))

(e0 (make-env)))

(eval code-fragment e0))))

 

Explicit environment manipulation has the disadvantage of being hostile against compiling. (See notes about compilation in the Common Lisp example.)

However, our two <code>let</code> constructs carefully save and restore the dynamic environment (and therefore any prior value of <code>x</code>), even in the face of exceptions, and

 

 

(defun eval-subtract-for-two-values-of-x (code-fragment x1 x0)

(let ((x x0)) (eval code-fragment))))

 

 

=={{header|UNIX Shell}}==

The backquotes <tt>` ... `</tt> capture the standard output of a subshell. Changes to parameter ''x'' in the subshell will not affect its parent shell.

 

set -- "`x=$2; eval "$1"`" "`x=$3; eval "$1"`"

expr "$2" - "$1"

echo $p

' 3 5

 

=={{header|zkl}}==

f:=Compiler.Compiler.compileText(text);

f.x = x; // set free var in compiled blob

}

const TEXT="var x; x*2"; // variables need to be declared

This is not a complete solution but close.

 

Another way to do this is to create a class on the fly that contains the code to be run and reusing that class. The class just acts like as a container for x and a function:

returnClass(x) is required in a constructor if you want to return something other than self. klass.x=y pokes y into the instance variable x. Running the constructor runs x*2.

{{out}}<pre>4</pre>

{{omit from|GUISS|Does not have variables}}

{{omit from|Lily}}