tasks a-s

Task/Runtime-evaluation-In-an-environment/0DESCRIPTION

@@ -0,0 +1,11 @@
+ 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:
+* 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>
+* does not make <var>x</var> a ''global'' variable
+or note that these are impossible.
+
+===See also===
+* For more general examples and language-specific details, see [[Eval]].
+* [[Dynamic variable names]] is a similar task.

Task/Runtime-evaluation-In-an-environment/ALGOL-68/runtime-evaluation-in-an-environment.alg

@@ -0,0 +1,3 @@
+PROC eval_with_x = (STRING code, INT a, b)STRING:
+	(INT x=a; evaluate(code) ) + (INT x=b; evaluate(code));
+print((eval_with_x("2 ** x", 3, 5), new line))

Task/Runtime-evaluation-In-an-environment/AutoHotkey/runtime-evaluation-in-an-environment.ahk

@@ -0,0 +1,32 @@
+msgbox % first := evalWithX("x + 4", 5)
+msgbox % second := evalWithX("x + 4", 6)
+msgbox % second - first
+return
+
+evalWithX(expression, xvalue)
+{
+global script
+script =
+(
+    expression(){
+    x = %xvalue%  ; := would need quotes
+    return %expression%
+  }
+)
+renameFunction("expression", "")  ; remove any previous expressions
+gosub load ; cannot use addScript inside a function yet
+exp := "expression"
+return %exp%()
+}
+
+load:
+DllCall(A_AhkPath "\addScript","Str",script,"Uchar",0,"Cdecl UInt")
+return
+
+renameFunction(funcName, newname){
+static
+x%newname% := newname   ; store newname in a static variable so its memory is not freed
+strput(newname, &x%newname%, strlen(newname) + 1)
+if fnp := FindFunc(funcName)
+  numput(&x%newname%, fnp+0, 0, "uint")
+}

Task/Runtime-evaluation-In-an-environment/BBC-BASIC/runtime-evaluation-in-an-environment.bbc

@@ -0,0 +1,8 @@
+      expression$ = "x^2 - 7"
+      one = FN_eval_with_x(expression$, 1.2)
+      two = FN_eval_with_x(expression$, 3.4)
+      PRINT two - one
+      END
+
+      DEF FN_eval_with_x(expr$, x)
+      = EVAL(expr$)

Task/Runtime-evaluation-In-an-environment/Common-Lisp/runtime-evaluation-in-an-environment-1.lisp

@@ -0,0 +1,4 @@
+(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)))

Task/Runtime-evaluation-In-an-environment/Common-Lisp/runtime-evaluation-in-an-environment-2.lisp

@@ -0,0 +1,2 @@
+(eval-with-x '(exp x) 0 1)
+=> 1.7182817

Task/Runtime-evaluation-In-an-environment/Common-Lisp/runtime-evaluation-in-an-environment-3.lisp

@@ -0,0 +1,5 @@
+(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)))

Task/Runtime-evaluation-In-an-environment/E/runtime-evaluation-in-an-environment-1.e

@@ -0,0 +1,15 @@
+# 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`    # bind x and capture its resolver and the
+    def x                      # 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
+}

Task/Runtime-evaluation-In-an-environment/E/runtime-evaluation-in-an-environment-2.e

@@ -0,0 +1,2 @@
+? evalWithX(e`(x :float64).exp()`, 0, 1)
+# value: 1.7182818284590455

Task/Runtime-evaluation-In-an-environment/Forth/runtime-evaluation-in-an-environment-1.fth

@@ -0,0 +1,7 @@
+: f-" ( a b snippet" -- )
+  [char] " parse   ( code len )
+  2dup 2>r evaluate
+  swap 2r> evaluate
+  - . ;
+
+2 3 f-" dup *"   \ 5  (3*3 - 2*2)

Task/Runtime-evaluation-In-an-environment/Forth/runtime-evaluation-in-an-environment-2.fth

@@ -0,0 +1,15 @@
+: :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

Task/Runtime-evaluation-In-an-environment/Genyris/runtime-evaluation-in-an-environment-1.genyris

@@ -0,0 +1,7 @@
+defmacro add100() (+ x 100)
+
+var x 23
+var firstresult (add100)
+x = 1000
+print
+    + firstresult (add100)

Task/Runtime-evaluation-In-an-environment/Genyris/runtime-evaluation-in-an-environment-2.genyris

@@ -0,0 +1,8 @@
+def add100() (+ .x 100)
+
+(dict)                 # create an environment capable of holding dynamic bindings
+   var .x 23           # create a binding in the dictionary
+   var firstresult (add100)
+   .x = 1000
+   print
+       + firstresult (add100)

Task/Runtime-evaluation-In-an-environment/Genyris/runtime-evaluation-in-an-environment-3.genyris

@@ -0,0 +1,4 @@
+(dict)
+   var .x 23
+   (dict)
+       print .x # fails

Task/Runtime-evaluation-In-an-environment/Go/runtime-evaluation-in-an-environment.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+    "bitbucket.org/binet/go-eval/pkg/eval"
+    "fmt"
+    "go/parser"
+    "go/token"
+)
+
+func main() {
+    // an expression on x
+    squareExpr := "x*x"
+
+    // parse to abstract syntax tree
+    fset := token.NewFileSet()
+    squareAst, err := parser.ParseExpr(squareExpr)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // create an environment or "world"
+    w := eval.NewWorld()
+
+    // allocate a variable
+    wVar := new(intV)
+
+    // bind the variable to the name x
+    err = w.DefineVar("x", eval.IntType, wVar)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // bind the expression AST to the world
+    squareCode, err := w.CompileExpr(fset, squareAst)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // directly manipulate value of variable within world
+    *wVar = 5
+    // evaluate
+    r0, err := squareCode.Run()
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // change value
+    *wVar--
+    // revaluate
+    r1, err := squareCode.Run()
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // print difference
+    fmt.Println(r0.(eval.IntValue).Get(nil) - r1.(eval.IntValue).Get(nil))
+}
+
+// int value implementation.
+type intV int64
+
+func (v *intV) String() string              { return fmt.Sprint(*v) }
+func (v *intV) Get(*eval.Thread) int64      { return int64(*v) }
+func (v *intV) Set(_ *eval.Thread, x int64) { *v = intV(x) }
+func (v *intV) Assign(t *eval.Thread, o eval.Value) {
+    *v = intV(o.(eval.IntValue).Get(t))
+}

Task/Runtime-evaluation-In-an-environment/Groovy/runtime-evaluation-in-an-environment-1.groovy

@@ -0,0 +1,3 @@
+def cruncher = { x1, x2, program ->
+   Eval.x(x1, program) - Eval.x(x2, program)
+}

Task/Runtime-evaluation-In-an-environment/Groovy/runtime-evaluation-in-an-environment-2.groovy

@@ -0,0 +1,5 @@
+def fibonacciProgram = '''
+x < 1 ? 0 : x == 1 ? 1 : (2..x).inject([0,1]){i, j -> [i[1], i[0]+i[1]]}[1]
+'''
+
+println "F(${10}) - F(${5}) = ${Eval.x(10, fibonacciProgram)} - ${Eval.x(5, fibonacciProgram)} = " + cruncher(10, 5, fibonacciProgram)

Task/Runtime-evaluation-In-an-environment/J/runtime-evaluation-in-an-environment-1.j

@@ -0,0 +1,7 @@
+   EvalWithX=. monad : 0
+    'CODE V0 V1'=. y
+    (". CODE [ x=. V1) - (". CODE [ x=. V0)
+   )
+
+   EvalWithX '^x';0;1
+1.71828183

Task/Runtime-evaluation-In-an-environment/J/runtime-evaluation-in-an-environment-2.j

@@ -0,0 +1,2 @@
+   (0&({::) -~&>/@:(128!:2&.>) 1 2&{) '^';0;1
+1.71828183

Task/Runtime-evaluation-In-an-environment/J/runtime-evaluation-in-an-environment-3.j

@@ -0,0 +1,3 @@
+EvalDiffWithY=: dyad define
+   -~/verb def x"_1 y
+)

Task/Runtime-evaluation-In-an-environment/J/runtime-evaluation-in-an-environment-4.j

@@ -0,0 +1,2 @@
+   '^y' EvalDiffWithY 0 1
+1.71828

Task/Runtime-evaluation-In-an-environment/J/runtime-evaluation-in-an-environment-5.j

@@ -0,0 +1,4 @@
+EvalDiffWithName=: adverb define
+:
+   -~/m adverb def ('(m)=.y';x)"_1 y
+)

Task/Runtime-evaluation-In-an-environment/J/runtime-evaluation-in-an-environment-6.j

@@ -0,0 +1,4 @@
+  '^George' 'George' EvalDiffWithName 0 1
+1.71828
+   'Z + 2^Z' 'Z' EvalDiffWithName 2 3
+5

Task/Runtime-evaluation-In-an-environment/Java/runtime-evaluation-in-an-environment.java

@@ -0,0 +1,2 @@
+ScriptEngine js = new ScriptEngineManager().getEngineByName("js");
+System.out.println(js.eval("function D(x){return x*2;} var x=3; x=D(x);"));

Task/Runtime-evaluation-In-an-environment/JavaScript/runtime-evaluation-in-an-environment-1.js

@@ -0,0 +1,7 @@
+function evalWithX(expr, a, b) {
+    var x = a;
+    var atA = eval(expr);
+    x = b;
+    var atB = eval(expr);
+    return atB - atA;
+}

Task/Runtime-evaluation-In-an-environment/JavaScript/runtime-evaluation-in-an-environment-2.js

@@ -0,0 +1 @@
+evalWithX('Math.exp(x)', 0, 1) // returns 1.718281828459045

Task/Runtime-evaluation-In-an-environment/Liberty-BASIC/runtime-evaluation-in-an-environment.liberty

@@ -0,0 +1,7 @@
+ expression$ = "x^2 - 7"
+Print (EvaluateWithX(expression$, 5) - EvaluateWithX(expression$, 3))
+End
+
+Function EvaluateWithX(expression$, x)
+    EvaluateWithX = Eval(expression$)
+End Function

Task/Runtime-evaluation-In-an-environment/Lua/runtime-evaluation-in-an-environment.lua

@@ -0,0 +1,4 @@
+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)

Task/Runtime-evaluation-In-an-environment/Mathematica/runtime-evaluation-in-an-environment.math

@@ -0,0 +1,3 @@
+Input source code is "10 x" , X is locally bound to 3 & 2 and the resulting expressions evaluated.
+(10 x /. x -> 3 ) - (10 x /. x -> 2 )
+-> 10

Task/Runtime-evaluation-In-an-environment/Metafont/runtime-evaluation-in-an-environment.metafont

@@ -0,0 +1,7 @@
+vardef evalit(expr s, va, vb) =
+save x,a,b; x := va; a := scantokens s;
+x := vb; b := scantokens s; a-b
+enddef;
+
+show(evalit("2x+1", 5, 3));
+end

Task/Runtime-evaluation-In-an-environment/Octave/runtime-evaluation-in-an-environment.octave

@@ -0,0 +1,10 @@
+function r = calcit(f, val1, val2)
+  x = val1;
+  a = eval(f);
+  x = val2;
+  b = eval(f);
+  r = b-a;
+endfunction
+
+p = "x .* 2";
+disp(calcit(p, [1:3], [4:6]));

Task/Runtime-evaluation-In-an-environment/Oz/runtime-evaluation-in-an-environment.oz

@@ -0,0 +1,8 @@
+declare
+   fun {EvalWithX Program A B}
+      {Compiler.evalExpression Program env('X':B) _}
+      -
+      {Compiler.evalExpression Program env('X':A) _}
+   end
+in
+   {Show {EvalWithX "{Exp X}" 0.0 1.0}}

Task/Runtime-evaluation-In-an-environment/PARI-GP/runtime-evaluation-in-an-environment.pari

@@ -0,0 +1,2 @@
+test(f,a,b)=f=eval(f);f(a)-f(b);
+test("x->print(x);x^2-sin(x)",1,3)

Task/Runtime-evaluation-In-an-environment/PHP/runtime-evaluation-in-an-environment.php

@@ -0,0 +1,11 @@
+<?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".
+?>

Task/Runtime-evaluation-In-an-environment/Perl-6/runtime-evaluation-in-an-environment.pl6

@@ -0,0 +1,9 @@
+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".

Task/Runtime-evaluation-In-an-environment/Perl/runtime-evaluation-in-an-environment.pl

@@ -0,0 +1,8 @@
+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".

Task/Runtime-evaluation-In-an-environment/PicoLisp/runtime-evaluation-in-an-environment.l

@@ -0,0 +1,12 @@
+(let Expression '(+ X (* X X))            # Local expression
+   (println
+      (+
+         (let X 3
+            (eval Expression) )
+         (let X 4
+            (eval Expression) ) ) )
+   (let Function (list '(X) Expression)   # Build a local function
+      (println
+         (+
+            (Function 3)
+            (Function 4) ) ) ) )

Task/Runtime-evaluation-In-an-environment/Pike/runtime-evaluation-in-an-environment-1.pike

@@ -0,0 +1,11 @@
+> int x=10;
+Result: 10
+> x * 5;
+Result: 50
+> dump wrapper
+Last compiled wrapper:
+001: mapping(string:mixed) ___hilfe = ___Hilfe->variables;
+002: # 1
+003: mixed ___HilfeWrapper() { return (([mapping(string:int)](mixed)___hilfe)->x) * 5; ; }
+004:
+>

Task/Runtime-evaluation-In-an-environment/Pike/runtime-evaluation-in-an-environment-2.pike

@@ -0,0 +1,8 @@
+string payload = "x * 5";
+
+program demo = compile_string("string eval(mixed x){ " + payload + "; }");
+
+demo()->eval(10);
+Result: 50
+demo()->eval(20);
+Result: 100

Task/Runtime-evaluation-In-an-environment/Python/runtime-evaluation-in-an-environment-1.py

@@ -0,0 +1,5 @@
+>>> def eval_with_x(code, a, b):
+	return eval(code, {'x':b}) - eval(code, {'x':a})
+
+>>> eval_with_x('2 ** x', 3, 5)
+24

Task/Runtime-evaluation-In-an-environment/Python/runtime-evaluation-in-an-environment-2.py

@@ -0,0 +1,9 @@
+>>> 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

Task/Runtime-evaluation-In-an-environment/R/runtime-evaluation-in-an-environment.r

@@ -0,0 +1,15 @@
+evalWithAB <- function(expr, var, a, b) {
+  env <- new.env()           # provide a separate env, so that the choosen
+  assign(var, a, envir=env)  # var name do not collide with symbols inside
+                             # this function (e.g. it could be even "env")
+  atA <- eval(parse(text=expr), env)
+                             # and then evaluate the expression inside this
+                             # ad hoc env-ironment
+  assign(var, b, envir=env)
+  atB <- eval(parse(text=expr), env)
+  return(atB - atA)
+}
+
+print(evalWithAB("2*x+1", "x", 5, 3))
+print(evalWithAB("2*y+1", "y", 5, 3))
+print(evalWithAB("2*y+1", "x", 5, 3)) # error: object "y" not found

Task/Runtime-evaluation-In-an-environment/REBOL/runtime-evaluation-in-an-environment.rebol

@@ -0,0 +1,5 @@
+prog: [x * 2]
+fn: func [x] [do bind prog 'x]
+a: fn 2
+b: fn 4
+subtract b a

Task/Runtime-evaluation-In-an-environment/REXX/runtime-evaluation-in-an-environment.rexx

@@ -0,0 +1,9 @@
+/*REXX program to demonstrate some run-time evaulations.                */
+
+a=fact(3)
+b=fact(4)
+say b-a
+exit                                   /*stick a fork in it, we're done.*/
+
+/*───────────────────────────────────FACT subroutine────────────────────*/
+fact: procedure; parse arg n; !=1;   do j=2  to n;  !=!*j;  end;  return !

Task/Runtime-evaluation-In-an-environment/Ruby/runtime-evaluation-in-an-environment.rb

@@ -0,0 +1,9 @@
+def bind_x_to_value(x)
+  binding
+end
+
+def eval_with_x(code, a, b)
+  eval(code, bind_x_to_value(b)) - eval(code, bind_x_to_value(a))
+end
+
+puts eval_with_x('2 ** x', 3, 5) # Prints "24"

Task/Runtime-evaluation-In-an-environment/SNOBOL4/runtime-evaluation-in-an-environment-1.sno

@@ -0,0 +1,6 @@
+     compiled = code(' define("triple(x)") :(a);triple triple = 3 * x :(return)')  :<compiled>
+a    x = 1
+     first = triple(x)
+     x = 3
+     output = triple(x) - first
+end

Task/Runtime-evaluation-In-an-environment/SNOBOL4/runtime-evaluation-in-an-environment-2.sno

@@ -0,0 +1,6 @@
+     compiled = code(' define("triple()") :(a);triple triple = 3 * x :(return)')  :<compiled>
+a    x = 1
+     first = triple(x)
+     x = 3
+     output = triple(x) - first
+end

Task/Runtime-evaluation-In-an-environment/Scheme/runtime-evaluation-in-an-environment.ss

@@ -0,0 +1,4 @@
+(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)))

Task/Runtime-evaluation-In-an-environment/TI-89-BASIC/runtime-evaluation-in-an-environment.ti-89

@@ -0,0 +1,12 @@
+evalx(prog, a, b)
+Func
+  Local x,eresult1,eresult2
+  a→x
+  expr(prog)→eresult1
+  b→x
+  expr(prog)→eresult2
+  Return eresult2-eresult1
+EndFunc
+
+■ evalx("ℯ^x", 0., 1)
+                      1.71828

Task/Runtime-evaluation-In-an-environment/Tcl/runtime-evaluation-in-an-environment-1.tcl

@@ -0,0 +1,9 @@
+proc eval_twice {func a b} {
+    set x $a
+    set 1st [expr $func]
+    set x $b
+    set 2nd [expr $func]
+    expr {$2nd - $1st}
+}
+
+puts [eval_twice {2 ** $x} 3 5] ;# ==> 24

Task/Runtime-evaluation-In-an-environment/Tcl/runtime-evaluation-in-an-environment-2.tcl

@@ -0,0 +1,4 @@
+proc eval_with_x {code val1 val2} {
+    expr {[set x $val2; eval $code] - [set x $val1; eval $code]}
+}
+eval_with_x {expr {2**$x}} 3 5 ;# ==> 24

Task/Runtime-evaluation-In-an-environment/UNIX-Shell/runtime-evaluation-in-an-environment.sh

@@ -0,0 +1,15 @@
+eval_with_x() {
+	set -- "`x=$2; eval "$1"`" "`x=$3; eval "$1"`"
+	expr "$2" - "$1"
+}
+
+eval_with_x '
+	# compute 2 ** $x
+	p=1
+	while test $x -gt 0; do
+		p=`expr $p \* 2`
+		x=`expr $x - 1`
+	done
+	echo $p
+' 3 5
+# Prints '24'