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

Output:

<pre>

<br>

Given the above, the task may easily be implemented along these lines:

on task_with_x(pgrm, x1, x2)

local rslt1, rslt2

rslt2 - rslt1

end task_with_x

Example usage (for legibility purposes, the program is stored into an intermediate variable):

set pgrm_with_x to "

on run {x}

 

task_with_x(pgrm_with_x, 3, 5)

The result is 24.0 (a real number).

 

 

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

 

 

Here's another version which avoids the global by compiling a local function with a single argument x (the ~'x is how to avoid automatic namespace qualification of symbols in a syntax quote):

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

(let [func (eval `(fn [~'x] ~program))]

(- (func b) (func a))))

 

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

 

Using VM console client:

import extensions'scripting;

 

console.printLine(

text,",",arg," = ",program.eval(arg.toReal()));

{{out}}

<pre>

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

=={{header|Factor}}==

Being a stack-based language, there is usually no need to bind data stack objects to a variable name. This is the idiomatic way to do it, with <code>eval</code> referencing what it needs from the data stack:

: eval-bi@- ( a b program -- n )

Also note that, since programs are first-class denizens in Factor, the use cases for <code>eval</code> are few. Normally, you would pass in a program as a quotation:

However, we can adhere to the letter of the task. Although we are using a dynamic variable for x, it exists in a temporary, non-global namespace. As far as I can tell, <code>eval</code> is unaware of surrounding lexical scope.

: eval-with-x ( a b program -- n )

tuck

65

IN: scratchpad x get .

 

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

From Javascript entry.

function evalWithX(expr, a, b) {

var x = a;

evalWithX('Math.exp(x)', 1, 0) ==> -1.71828182845905

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

return quote

x = $a

end

 

 

One can even perform the task without using macros:

 

a = eval(quote let x = $a; return $expr end end)

b = eval(quote let x = $b; return $expr end end)

 

evalwithx(:(2 ^ x), 3, 5)

 

=={{header|Kotlin}}==

{{trans|JavaScript}}

When you try to compile the following program, it will appear to the compiler that the local variable 'x' is assigned but never used and warnings will be issued accordingly. You can get rid of these warnings by compiling using the -nowarn flag.

 

fun evalWithX(expr: String, a: Double, b: Double) {

fun main(args: Array<String>) {

println(evalWithX("Math.exp(x)", 0.0, 1.0))

 

{{out}}

 

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

macro eval(s, x: static[string]): untyped =

parseStmt(&"let x={x}\n{s}")

 

{{out}}

<pre>

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

still not escape the eval() context, and still have to be explicitly requested as a

return value, as per the second {"x"} parameter [aka rset] to eval().

<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.1"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">eval_with_x</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"integer x = power(2,x)"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>

{{out}}

(As in 2<small>⁵</small> - 2<small>³</small> === 32 - 8 === 24)

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

{{Works with|rakudo|2015-12-22}}

For security, you must explicitly allow use of 'EVAL'.

sub eval_with_x($code, *@x) { [R-] @x.map: -> \x { EVAL $code } }

 

say eval_with_x('3 * x', 5, 10); # Says "15".

 

=={{header|REBOL}}==

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

a: fn 2

b: fn 4

 

Result:

 

=={{header|REXX}}==

say '──────── enter the 1st expression to be evaluated:'

 

 

drop x /*X var. is no longer a global variable*/

{{out|output|text=&nbsp;}}

<pre>

 

=={{header|Ring}}==

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

one = evalwithx(expression, 1.2)

func evalwithx expr, x

return eval(expr)

Output:

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

 

=={{header|Scala}}==

 

def evalWithX(expr: String, a: Double, b: Double)=

println(evalWithX("Math.exp(x)", 0.0, 1.0))

 

 

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

 

CLASS ENV;

 

END.

{{out}}

<pre>

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

The <code>(eval)</code> function returns a pair, where the first element is boolean flag indicating success of running the code, and the second element is a string containing the output of code execution.

 

 

MainModule: {

(to-Int (with x 1 (snd (eval code)))))

))

{{out}}

<pre>

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

 

However, it only appears to work with module level variables.

 

var x

 

Meta.eval("x = x - y")

 

{{out}}

 

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