gololang

Class EvaluationEnvironment

java.lang.Object

gololang.EvaluationEnvironment

public class EvaluationEnvironment
extends Object

An evaluation environment offers facilities for dynamic code compilation, loading and execution from Golo code as strings.

An evaluation environment is reusable across several executions. The only exception is when using asModule(), as attempts to load a module with the same name as an already loaded one fails.

Each instance of this class uses a dedicated GoloClassLoader, hence usual rules about classloader delegation and isolation apply to evaluation environments.

While dynamic code evaluation is useful, it shall still be used with care and parsimony. It is especially important not to abuse run(), as each invocation triggers the generation of a one-shot class.

Here is an example usage of this API:

 let env = EvaluationEnvironment()
 let code =
 """
 function a = -> "a."
 function b = -> "b."
 """
 let mod = env: anonymousModule(code)
 let a = fun("a", mod)
 let b = fun("b", mod)
 println(a())
 println(b())
 

While this class is expected to be used from Golo code, it can also be used as a convenient way to embed Golo into polyglot JVM applications.

Constructor Summary

Constructors

Constructor and Description
EvaluationEnvironment()

Method Summary

Methods

Modifier and Type	Method and Description
Object	anonymousModule(String source) Loads an anonymous module.
Object	asFunction(String source, String... argumentNames) Evaluates some code as the body of a function and returns it.
Object	asModule(String source) Evaluates a complete module, as in:
EvaluationEnvironment	clearImports() Clears all import symbols for the next code evaluation requests.
Object	def(String source) Defines a function, and returns it.
EvaluationEnvironment	imports(String head, String... tail) Imports symbols.
Object	run(String source) Runs some code as the body of a function and returns the value.
Object	run(String source, Map<String,Object> context) Runs some code as the body of a function and returns the value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

EvaluationEnvironment

public EvaluationEnvironment()

Method Detail

imports

public EvaluationEnvironment imports(String head,
                            String... tail)

Imports symbols.

Each symbol generates an equivalent import statement in the corresponding Golo code. Calling imports("foo.Bar", "bar.Baz") means that the subsequent code evaluations have import foo.Bar and import bar.Baz statements.

Note that this has no effect for asModule(String). Also, calling this method several times accumulates the imports, in order.

Parameters:

head - the first imported symbol.

tail - the next imported symbols.

Returns:

this evaluation environment.

clearImports

public EvaluationEnvironment clearImports()

Clears all import symbols for the next code evaluation requests.

Returns:

this evaluation environment.

asModule

public Object asModule(String source)

Evaluates a complete module, as in:

 let code =
 """
 module foo

 function a = -> "a!"
 function b = -> "b!"
 """
 let mod = env: asModule(code)
 let a = fun("a", mod)
 let b = fun("b", mod)
 println(a())
 println(b())
 

Parameters:

source - the module Golo source code as a string.

Returns:

the corresponding module, as a Class.

See Also:

Predefined.fun(Object, Object)

anonymousModule

public Object anonymousModule(String source)

Loads an anonymous module. This is the same as asModule(String), except that the code does not contain a module declaration.

 let code =
 """
 function a = -> "a!"
 function b = -> "b!"
 """
 let mod = env: anonymousModule(code)
 let a = fun("a", mod)
 let b = fun("b", mod)
 println(a())
 println(b())
 

Parameters:

source - the module Golo source code as a string.

Returns:

the corresponding module, as a Class.

See Also:

Predefined.fun(Object, Object)

def

public Object def(String source)

Defines a function, and returns it.

 let code = "|a, b| -> (a + b) * 2"
 let f = env: def(code)
 println(f(10, 20))
 

Parameters:

source - the function code.

Returns:

the function as a MethodHandle instance.

asFunction

public Object asFunction(String source,
                String... argumentNames)

Evaluates some code as the body of a function and returns it.

 let code = "return (a + b) * 2"
 let f = env: asFunction(code, "a", "b")
 println(f(10, 20))
 

Parameters:

source - the function body source code.

argumentNames - the argument names.

Returns:

the function as a MethodHandle instance.

run

public Object run(String source)

Runs some code as the body of a function and returns the value. The code shall use return statements to provide return values, if any.

 let code = """println(">>> run")
 foreach (i in range(0, 3)) {
   println("w00t")
 }
 return 666"""
 env: run(code)

 

Parameters:

source - the source to run.

Returns:

the return value, or null if no return statement is used.

run

public Object run(String source,
         Map<String,Object> context)

Runs some code as the body of a function and returns the value. This is the same as run(String), but it takes a set of reference bindings in a map. Each reference is equivalent to a let statement.

 let code = """println(">>> run_map")
 println(a)
 println(b)
 """
 let values = java.util.TreeMap(): add("a", 1): add("b", 2)
 env: run(code, values)
 

Parameters:

source - the source to run.

context - a map of bindings from name to values.

Returns:

the return value, or null if no return statement is used.