(* Title:  BaseDefinitions/method-def.sml

    Author: Walther Neuper

    (c) due to copyright terms

 Here is a minimum of code required for Know_Store.thy.

 For main code see structure Method.

 *)

 signature METHOD_DEFINITION =

 sig

   type id = References_Def.id;

   val id_empty: id

   val id_to_string: id -> string

   type T

 (*type met*)

   val empty: T

 (*val e_met: T*)

   type store

 (*type mets*)

   val empty_store: T Store.node

 (*val e_Mets: T Store.node*)

   val check_unique: Check_Unique.id -> T Store.T -> unit

 (*val check_metguh_unique: Check_Unique.id -> T Store.T -> unit*)

 (* ---- for tests only: shifted from below to remove the Warning "unused" at fun.def. --------- *)

   (*NONE*)

 (*/-------------------------------------------------------- ! aktivate for Test_Isac BEGIN ---\* )

   (*NONE*)

 ( *\--- ! aktivate for Test_Isac END ----------------------------------------------------------/*)

 end

 (**)

 structure Meth_Def(**): METHOD_DEFINITION(**) =

 struct

 (**)

 type id = References_Def.id;

 val id_empty = References_Def.empty_meth_id;

 val id_to_string = References_Def.id_to_string;

 (* data for methods stored in 'methods'-database *)

 type T =                          (* TODO WN200620: review ---------------------vvvvv         *)

   {guh       : Check_Unique.id,   (* unique within Isac_Knowledge, for html-presentation      *)

   mathauthors: string list,       (* copyright                                                *)

   init       : References_Def.id, (* DEL: WN060721 pblID introduced mistakenly                *)

   rew_ord'   : Rule_Def.rew_ord', (* for ordered rewriting by Tactic.Rewrite                  *)

   erls       : Rule_Set.T,        (* for conditions in rewriting by Tactic.Rewrite            *)

   srls       : Rule_Set.T,        (* for evaluating Prog_Expr                                 *)

   crls       : Rule_Set.T,        (* DEL: for check_elementwise                               *)

   nrls       : Rule_Set.T,        (* for rewriting by Tactic.Rewrite                          *)

   errpats    : Error_Pattern_Def.T list, (* error patterns expected in this method            *)

   calc       : Rule_Def.calc list,(* ?DEL                                                     *)

   scr        : Rule.program,      (* filled in Method.prep_input                              *)

   prls       : Rule_Set.T,        (* for evaluation of preconditions in "#Where" on "#Given"  *)

   ppc        : Model_Pattern.T,   (* contains "#Given", "#Where", "#Find", "#Relate"

                                      for constraints on identifiers see "O_Model.cpy_nam"     *)

   pre        : term list          (* ? DEL, as soon as they are input interactively ?         *)

 	};

 val empty = {guh = "met_empty", mathauthors = [], init = id_empty, rew_ord' = Rewrite_Ord.e_rew_ord',

 	erls = Rule_Set.empty, srls = Rule_Set.empty, prls = Rule_Set.empty, calc = [], crls = Rule_Set.empty,

 	errpats = [], nrls = Rule_Set.empty, ppc = [], pre = [], scr = Rule.Empty_Prog};

 val empty_store = Store.Node ("empty_meth_id", [empty],[]);

 type store = (T Store.node) list;

 val check_unique =

   Check_Unique.message (Check_Unique.collect (#guh: T -> Check_Unique.id));

 (**)end(**)