Same as apply(MLValue[D]) but first converts arg into an MLValue (i.e., transfers it to the Isabelle process).

Invokes the function on a value arg stored in the Isabelle process.

Note that the result r of the computation happens in a future (inside an MLValue), so exceptions in the ML code are not immediately thrown. To force exceptions, use, e.g., r.retrieveNow or r.force.

Returns a textual representation of the value in the ML process as it is stored in the object store (i.e., encoded as an exception). E.g., an integer 3 would be represented as "E_Int 3".

Waits till the computation of this value (in the Isabelle process) has finished. (Or until an exception is thrown.)

A future containing this value with the computation completed. In particular, if this value throws an exception upon computation, the future holds that exception.

Roughly the same as Future { this.force }.

Returns this MLValue as an MLFunction, assuming this MLValue has a type of the form MLValue[D => R]. If this MLValue is MLValue[D => R], it means it references a function value in the ML process. Converting it to an MLFunction <: MLValue gives us access to additional methods for applying this function.

Analogous to function but for functions that take a pair as argument, i.e., this : MLValue[((D1, D2)) => R].

Analogous to function but for functions that take a 3-tuple as argument, i.e., this : MLValue[((D1, D2, D3)) => R].

Analogous to function but for functions that take a 4-tuple as argument, i.e., this : MLValue[((D1, D2, D3, D4)) => R].

Analogous to function but for functions that take a 5-tuple as argument, i.e., this : MLValue[((D1, D2, D3, D4, D5)) => R].

Analogous to function but for functions that take a 6-tuple as argument, i.e., this : MLValue[((D1, D2, D3, D4, D5, D6)) => R].

Analogous to function but for functions that take a 7-tuple as argument, i.e., this : MLValue[((D1, D2, D3, D4, D5, D6, D7)) => R].

Specialized type cast that inserts MLValue[] in arbitrary positions in the type parameter of this MLValue. E.g., we can type cast this : MLValue[List[X]] to MLValue[List[MLValue[X]]] by invoking this.insertMLValue[List,X] Such type casts are safe because the the way MLValue[...] is interpreted in the type parameter to MLValue (see MLValueConverter (TODO: document that one)). The same type cast could be achieved using .asInstanceOf, but insertMLValue guarantees that no unsafe cast is accidentally performed.

Specialized type cast that removes MLValue[] in arbitrary positions in the type parameter of this MLValue. E.g., we can type cast this : MLValue[List[MLValue[X]]] to MLValue[List[X]] by invoking this.removeMLValue[List,X] Such type casts are safe because the the way MLValue[...] is interpreted in the type parameter to MLValue (see MLValueConverter (TODO: document that one)). The same type cast could be achieved using .asInstanceOf, but insertMLValue guarantees that no unsafe cast is accidentally performed.

Retrieves the value referenced by this MLValue from the Isabelle process.

In particular, the value in the Isabelle process (a value in ML) is translated to a Scala value.

Like retrieve but returns the Scala value directly instread of a future (blocks till the computation and transfer finish.

A utility method that returns "" if this value was successfully computed, " (computing)" if it still computes, and " (failed)" if it finished with an exception.

This can be useful to constructing human readable messages about this value.