theory Base

imports Main 

        "~~/src/HOL/Library/LaTeXsugar"

uses

  ("output_tutorial.ML")

  ("antiquote_setup.ML")

begin

notation (latex output)

  Cons ("_ # _" [66,65] 65)

(* re-definition of various ML antiquotations     *)

(* to have a special tag for text enclosed in ML; *)

(* they also write the code into a separate file  *)

ML {*

val filename = Attrib.setup_config_string @{binding "filename"} (K "File_Code.ML")

*}

ML {*

fun write_file txt thy =

let 

  val stream = Config.get_global thy filename

               |> TextIO.openAppend 

in

  TextIO.output (stream, txt); 

  TextIO.flushOut stream;       (* needed ?*)

  TextIO.closeOut stream

end

*}

ML {*

fun write_file_ml_blk txt thy =

let

  val pre  = implode ["\n", "ML ", "{", "*", "\n"]

  val post = implode ["\n", "*", "}", "\n"]

  val _ = write_file (enclose pre post txt) thy

in

  thy

end

fun write_file_setup_blk txt thy =

let

  val pre  = implode ["\n", "setup ", "{", "*", "\n"]

  val post = implode ["\n", "*", "}", "\n"]

  val _ = write_file (enclose pre post txt) thy

in

  thy

end

fun write_file_lsetup_blk txt lthy =

let

  val pre  = implode ["\n", "local_setup ", "{", "*", "\n"]

  val post = implode ["\n", "*", "}", "\n"]

  val _ = write_file (enclose pre post txt) (Proof_Context.theory_of lthy)

in

  lthy

end

*}

ML {*

fun open_file name thy =

let  

  val _ = tracing ("Open File: " ^ name)

  val _ = TextIO.openOut name

in 

  Config.put_global filename name thy

end

*}

ML {*

fun open_file_with_prelude name txts thy =

let 

  val thy' = open_file name thy 

  val _ = write_file (cat_lines txts) thy'

in

  thy'

end

*}

ML {*

fun propagate_env (context as Context.Proof lthy) =

      Context.Proof (Local_Theory.map_contexts (ML_Env.inherit context) lthy)

  | propagate_env context = context

fun propagate_env_prf prf = Proof.map_contexts

  (Context.proof_map (ML_Env.inherit (Context.Proof (Proof.context_of prf)))) prf

*}

ML {*

val _ =

  Outer_Syntax.command "ML" "eval ML text within theory"

    (Keyword.tag "TutorialML" Keyword.thy_decl)

    (Parse.position Parse.text >> 

      (fn (txt, pos) =>

        Toplevel.generic_theory

         (ML_Context.exec 

           (fn () => ML_Context.eval_text true pos txt) 

              #> propagate_env #> Context.map_theory (write_file_ml_blk txt))))

*}

ML {*

val _ =

  Outer_Syntax.command "ML_prf" "ML text within proof" 

    (Keyword.tag "TutorialMLprf" Keyword.prf_decl)

    (Parse.ML_source >> (fn (txt, pos) =>

      Toplevel.proof (Proof.map_context (Context.proof_map

        (ML_Context.exec (fn () => ML_Context.eval_text true pos txt))) #> propagate_env_prf)))

*}

ML {*

val _ =

  Outer_Syntax.command "ML_val" "diagnostic ML text" 

  (Keyword.tag "TutorialML" Keyword.diag)

    (Parse.ML_source >> Isar_Cmd.ml_diag true)

*}

ML {*

val _ =

  Outer_Syntax.command "setup" "ML theory setup" 

    (Keyword.tag_ml Keyword.thy_decl)

      (Parse.ML_source >> (fn (txt, pos) => 

        (Toplevel.theory (Isar_Cmd.global_setup (txt, pos) #> write_file_setup_blk txt))))

*}

ML {*

val _ =

  Outer_Syntax.local_theory "local_setup" "ML local theory setup" 

    (Keyword.tag_ml Keyword.thy_decl)

      (Parse.ML_source >> (fn (txt, pos) => 

         Isar_Cmd.local_setup (txt, pos) #> write_file_lsetup_blk txt));

*}

ML {*

fun P n = @{term "P::nat \<Rightarrow> bool"} $ (HOLogic.mk_number @{typ "nat"} n) 

fun rhs 1 = P 1

  | rhs n = HOLogic.mk_conj (P n, rhs (n - 1))

fun lhs 1 n = HOLogic.mk_imp (HOLogic.mk_eq (P 1, P n), rhs n)

  | lhs m n = HOLogic.mk_conj (HOLogic.mk_imp 

                 (HOLogic.mk_eq (P (m - 1), P m), rhs n), lhs (m - 1) n)

fun de_bruijn n =

  HOLogic.mk_Trueprop (HOLogic.mk_imp (lhs n n, rhs n))

*}

use "output_tutorial.ML"

use "antiquote_setup.ML"

setup {* OutputTutorial.setup *}

setup {* AntiquoteSetup.setup *}

end