X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=src%2Fast.mli;h=225e42975f75bf66431ad746e19026f865778206;hb=5e13f1e2a3dc1237fcf2fa141d8379bdd36bde61;hp=978099e5d24bfe26bc406113485a924a9dda1e28;hpb=24cc20b33e3d81ed7d754391bef929276c1f4f42;p=goals.git

diff --git a/src/ast.mli b/src/ast.mli
index 978099e..225e429 100644
--- a/src/ast.mli
+++ b/src/ast.mli
@@ -26,6 +26,9 @@ module Env : sig
   val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
   val filter: (key -> 'a -> bool) -> 'a t -> 'a t
   val bindings: 'a t -> (key * 'a) list
+
+  (* This is not the normal Map.merge function. *)
+  val merge : 'a t -> 'a t -> 'a t
 end
 
 (** Location where we parsed from $loc = $startpos, $endpos *)
@@ -38,57 +41,58 @@ val string_loc : unit -> loc -> string
     variable or goal name -> expression. *)
 type env = expr Env.t
 and pattern =
-  (** match tactic such as *file ("filename") *)
-  | PTactic of loc * id * substs list
-  (** match named variable, which must be a string, ETactic or
-      a list of those *)
-  | PVar of loc * id
+  | PPred of loc * id * substs list
+  (** match predicate such as is-file ("filename") *)
 and expr =
-  (** goal (params) = patterns : exprs = code *)
-  | EGoal of loc * goal
-  (** goalname (params) etc. *)
+  | EGoalDefn of loc * goal
+  (** goal (params) = patterns : exprs code *)
+  | EFuncDefn of loc * func
+  (** function (params) = code *)
+  | EPredDefn of loc * pred
+  (** predicate (params) = code *)
   | ECall of loc * id * expr list
-  (** *tactic (params) etc. *)
-  | ETactic of loc * id * expr list
-  (** variable, or goal call with no parameters *)
+  (** call goal (params) or function (params) *)
+  | EPredCtor of loc * id * expr list
+  (** constructor is-predicate (params) *)
   | EVar of loc * id
-  (** list *)
+  (** variable, or goal call with no parameters *)
   | EList of loc * expr list
-  (** string with %-substitutions *)
+  (** list *)
   | ESubsts of loc * substs
-  (** constant expression, such as a plain string, int, boolean, etc. *)
+  (** string with %-substitutions *)
   | EConstant of loc * constant
+  (** constant expression, such as a plain string, int, boolean, etc. *)
 and constant =
   | CString of string
 and goal = param_decl list * pattern list * expr list * code option
-  (** Goal parameter is the parameter name and an optional default value. *)
-and param_decl = id
+and func = param_decl list * returning * bool * code
+and pred = param_decl list * code
+and param_decl = id             (** goal/func/pred parameter. *)
 and id = string
-and code = substs
+and code = substs * bool        (** code + quiet flag *)
+and returning = RetExpr | RetStrings | RetString
 and substs = subst list
 and subst =
-  (** String literal part. *)
   | SString of string
-  (** %-substitution. *)
+  (** String literal part. *)
   | SVar of id
+  (** %-substitution. *)
 
+val getvar : env -> loc -> id -> expr
 (** Look up a variable in the environment.  Raise [Failure _]
     if not found. *)
-val getvar : env -> loc -> id -> expr
 
+val getgoal : env -> loc -> id -> goal
 (** Look up a goal in the environment.  Raise [Failure _] if not
     found or if the named variable is not a goal. *)
-val getgoal : env -> loc -> id -> goal
 
-(** Take any expression and simplify it down to a constant.
-    If the expression cannot be simplified then this raises
-    [Failure _]. *)
-val to_constant : env -> expr -> constant
+val getfunc : env -> loc -> id -> func
+(** Look up a function in the environment.  Raise [Failure _] if not
+    found or if the named variable is not a function. *)
 
-(** Take a substitution list and try to turn it into a simple
-    string by evaluating every variable.  If not possible this
-    raises [Failure _]. *)
-val substitute : env -> loc -> substs -> string
+val getpred : env -> loc -> id -> pred
+(** Look up a predicate in the environment.  Raise [Failure _] if not
+    found or if the named variable is not a predicate. *)
 
 (** This is used for incrementally building Ast.substs in the parser. *)
 module Substs : sig
@@ -100,9 +104,8 @@ module Substs : sig
   val add_var : t -> string -> unit
 end
 
-(** Print all definitions in an environment. *)
-val print_env : out_channel -> env -> unit
-
 (** %a formatters. *)
+val print_env : out_channel -> env -> unit
 val string_pattern : unit -> pattern -> string
 val string_expr : unit -> expr -> string
+val print_expr : out_channel -> expr -> unit