Blocks until this future value is computed. (Or throws an exception if the computation fails.)

Initializes a proof context (ML type Proof.context) based on this theory. Note: a new proof context is initialized each time this method is invoked. In time-critical situations, it may be best to invoke this method only once.

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

A future containing this object 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 }.

Imports an ML structure from a theory into the global ML namespace.

In an Isabelle theory T, it is possible to include ML source code using the ML_file command and related commands. In that ML source code, new symbols (values, types, structures) can be declared. These will be visible to further ML code in the same theory T and in theories that import T. However, it is not directly possible to use those symbols in ML code on the ML toplevel (i.e., in commands such as Isabelle.executeMLCode or MLValue.compileValue and friends). Instead, the symbols must be imported using this method. (Only supported for ML structures, not for values or types that are declared outside a structure.) importMLStructureNow(name) (or importMLStructure(name) for asynchronous execution) imports the structure called name under a new (unique) name into the toplevel, and returns the name of the structure.

We give an example.

File importMe.ML:

structure ImportMe = struct
val num = 123
end

This declares a structure ImportMe with a value member num.

File ImportMeThy.thy:

theory ImportMeThy imports Main begin

ML_file "importMe.ML"

end

This declares a theory which loads the ML code from "importMe.ML" (and thus all theories importing ImportMeThy have access to the ML structure ImportMe).

In Scala:

implicit val isabelle = new Isabelle(... suitable setup ...)
val thy : Theory = Theory(Path.of("ImportMeThy.thy"))              // load the theory TestThy
val num1 : MLValue[Int] = MLValue.compileValue("ImportMe.num")     // fails
val importMe : String = thy.importMLStructureNow("ImportMe")       // import the structure Test into the ML toplevel
val num2 : MLValue[Int] = MLValue.compileValue(s"${importMe}.num") // access Test (under new name) in compiled ML code
println(num2.retrieveNow)                                          // ==> 123

Returns a future that completes when the computation of this object is complete. (Or that holds an exception if that computation throws an exception.) However, upon successful completion, the future may return an arbitrary (and thus useless) value. May be faster to implement than forceFuture because there may be already a future available but that returns the wrong value.

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.

Imports an ML structure from a theory into the global ML namespace.

WARNING: This has a global effect on the Isabelle process because it modifies the ML name space. Use importMLStructure(String) instead.

In an Isabelle theory T, it is possible to include ML source code using the ML_file command and related commands. In that ML source code, new symbols (values, types, structures) can be declared. These will be visible to further ML code in the same theory T and in theories that import T. However, it is not directly possible to use those symbols in ML code on the ML toplevel (i.e., in commands such as Isabelle.executeMLCode or MLValue.compileValue and friends). Instead, the symbols must be imported using this method. (Only supported for ML structures, not for values or types that are declared outside a structure.) importMLStructure(name,newName) will import the structure called name under the new name newName into the toplevel.

We give an example.

File test.ML:

structure Test = struct
val num = 123
end

This declares a structure Test with a value member num.

File TestThy.thy:

theory TestThy imports Main begin

ML_file "test.ML"

end

This declares a theory which loads the ML code from "test.ML" (and thus all theories importing TestThy have access to the ML structure Test).

In Scala:

implicit val isabelle = new Isabelle(... suitable setup ...)
val thy : Theory = Theory("Draft.TestThy")                  // load the theory TestThy
val num1 : MLValue[Int] = MLValue.compileValue("Test.num")  // fails
thy.importMLStructure("Test", "Test")                       // import the structure Test into the ML toplevel
val num2 : MLValue[Int] = MLValue.compileValue("Test.num")  // access Test in compiled ML code
println(num2.retrieveNow)                                   // ==> 123