State Transaction Machine

The process_transaction function adds a new edge to the Dag without
executing the transaction (when possible).

The observe id function runs the transactions necessary to reach to the
state id.  Transaction being on a merged branch are not executed but
stored into a future.

The finish function calls observe on the tip of the current branch.

Imperative modifications to the environment made by some tactics are
now explicitly declared by the tactic and modeled as let-in/beta-redexes
at the root of the proof term. An example is the abstract tactic.

This is the work described in the Coq Workshop 2012 paper.

Coq is compile with thread support from now on.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@16674 85f007b7-540e-0410-9357-904b9bb8a0f7

1 files changed, 5 insertions, 2 deletions

diff --git a/checker/declarations.ml b/checker/declarations.ml
index 58a5f2602..0981cfd1a 100644
--- a/checker/declarations.ml
+++ b/checker/declarations.ml
@@ -434,12 +434,15 @@ let force_lazy_constr = function
 let subst_constant_def sub = function
   | Undef inl -> Undef inl
   | Def c -> Def (subst_constr_subst sub c)
-  | OpaqueDef lc -> OpaqueDef (subst_lazy_constr sub lc)
+  | OpaqueDef lc ->
+      OpaqueDef (Future.from_val (subst_lazy_constr sub (Future.join lc)))
+
+type constant_constraints = Univ.constraints Future.computation
 
 let body_of_constant cb = match cb.const_body with
   | Undef _ -> None
   | Def c -> Some (force_constr c)
-  | OpaqueDef c -> Some (force_lazy_constr c)
+  | OpaqueDef c -> Some (force_lazy_constr (Future.join c))
 
 let constant_has_body cb = match cb.const_body with
   | Undef _ -> false