Runtime evaluation/In an environment: Difference between revisions
→{{header|Metafont}}: if the problem was the "global" variable... fixed (as tcl, similar to php) |
trying to clarify some more... |
||
Line 1: | Line 1: | ||
{{task}} Given a program in the language 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. |
{{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: |
Do so in a way which: |
||
* does not involve string manipulation of source code |
* does not involve string manipulation of the input source code |
||
* is plausibly extensible to a runtime-chosen set of bindings rather than just <var>x</var> |
* 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 |
* does not make <var>x</var> a ''global'' variable |
Revision as of 02:06, 30 April 2009
You are encouraged to solve this task according to the task description, using any language you may know.
Given a program in the language (as a string or AST) with a free variable named x (or another name if that is not valid syntax), evaluate it with x bound to a provided value, then evaluate it again with x 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:
- does not involve string manipulation of the input source code
- is plausibly extensible to a runtime-chosen set of bindings rather than just x
- does not make x a global variable
or note that these are impossible.
For more general examples and language-specific details, see Eval.
Common Lisp
<lang lisp> (defun eval-with-x (program a b)
(let ((at-a (eval `(let ((x ',a)) ,program))) (at-b (eval `(let ((x ',b)) ,program)))) (- at-b at-a)))
</lang>
<lang lisp> (eval-with-x '(exp x) 0 1) => 1.7182817 </lang>
This version ensures that the program is compiled, once, for more efficient execution:
<lang lisp> (defun eval-with-x (program a b)
(let* ((f (compile nil `(lambda (x) ,program))) (at-a (funcall f a)) (at-b (funcall f b))) (- at-b at-a)))
</lang>
E
<lang e># Constructing an environment has to be done by way of evaluation for historical reasons which will hopefully be entirely eliminated soon. def bindX(value) {
def [resolver, env] := e` def x # bind x and capture its resolver and the resulting environment `.evalToPair(safeScope) resolver.resolve(value) # set the value return env
}
def evalWithX(program, a, b) {
def atA := program.eval(bindX(a)) def atB := program.eval(bindX(b)) return atB - atA
}</lang>
<lang e>? evalWithX(e`(x :float64).exp()`, 0, 1)
- value: 1.7182818284590455</lang>
Forth
EVALUATE invokes the Forth interpreter on the given string. <lang forth>
- f-" ( a b snippet" -- )
[char] " parse ( code len ) 2dup 2>r evaluate swap 2r> evaluate - . ;
2 3 f-" dup *" \ 5 (3*3 - 2*2) </lang> This can be used to treat a data stream as code, or to provide a lightweight macro facility when used in an IMMEDIATE word. <lang forth>
- :macro ( "name <char> ccc<char>" -- )
: [CHAR] ; PARSE POSTPONE SLITERAL POSTPONE EVALUATE POSTPONE ; IMMEDIATE
- macro times 0 do ;
- test 8 times ." spam " loop ;
see test
- test
8 0 DO .\" spam " LOOP ; ok
</lang>
Metafont
<lang metafont>vardef evalit(expr s, v) = save x; x := v; scantokens s enddef;
a := evalit("2x+1", 5); b := evalit("2x+1", 2); show (a-b); end</lang>
Octave
<lang octave>function r = calcit(f, val)
x = val; r = eval(f);
endfunction
p = "x .* 2"; a = calcit(p, [1:3]); b = calcit(p, [4:6]);
disp(b-a);</lang>
Output:
6 6 6
Perl
<lang perl>sub eval_with_x
{my $code = shift; my $x = shift; my $first = eval $code; $x = shift; return eval($code) - $first;}
print eval_with_x('3 * $x', 5, 10), "\n"; # Prints "15".</lang>
PHP
<lang php><?php function eval_with_x($code, $a, $b) {
$x = $a; $first = eval($code); $x = $b; $second = eval($code); return $second - $first;
}
echo eval_with_x('return 3 * $x;', 5, 10), "\n"; # Prints "15". ?></lang>
Python
<lang python>>>> def eval_with_x(code, a, b): return eval(code, {'x':b}) - eval(code, {'x':a})
>>> eval_with_x('2 ** x', 3, 5) 24</lang>
Python: for multiple names
A slight change allows the evaluation to take multiple names: <lang python>>>> def eval_with_args(code, **kwordargs): return eval(code, kwordargs)
>>> code = '2 ** x' >>> eval_with_args(code, x=5) - eval_with_args(code, x=3) 24 >>> code = '3 * x + y' >>> eval_with_args(code, x=5, y=2) - eval_with_args(code, x=3, y=1) 7 >>> </lang>
Ruby
<lang ruby>def getBinding(x)
binding
end
def eval_with_x(code, a, b)
eval(code, getBinding(b)) - eval(code, getBinding(a))
end
puts eval_with_x('2 ** x', 3, 5) # Prints "24"</lang>
Scheme
Almost identical to the Common Lisp version above. <lang scheme>(define (eval-with-x prog a b)
(let ((at-a (eval `(let ((x ',a)) ,prog))) (at-b (eval `(let ((x ',b)) ,prog)))) (- at-b at-a)))</lang>
Tcl
<lang tcl>package require Tcl 8.5
proc evalit {func a} {
set r [apply $func $a] expr {$r}
}
set a [evalit {x {expr {2 ** $x}}} 3]; set b [evalit {x {expr {2 ** $x}}} 5]; puts [expr {$b - $a}]; </lang>