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

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

def bindX(value) {

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

return atB - atA

 

 

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

// parse to abstract syntax tree

fset := token.NewFileSet()

if err != nil {

fmt.Println(err)

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

 

=={{header|Java}}==

{{works with|Java|6+}}

 

 

 

Output:

 

=={{header|JavaScript}}==

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 Octave, undeclared variables are local.

 

x = val1;

a = eval(f);

b = eval(f);

r = b-a;

 

Output:

<pre>6 6 6</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|REBOL}}==

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

a: fn 2

b: fn 4

 

Result:

 

=={{header|REXX}}==

 

 

Output:

<pre>

</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|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]}

}

 

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

 

Func

Local x,eresult1,eresult2

 

■ evalx("ℯ^x", 0., 1)

 

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]]

 

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

 

{{Omit From|Ada}}

{{omit from|C}} <!-- static compiled -->

{{omit from|D}}

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