external_file "bar.c&quo= t; install_C_file "bar.c"

There are many
possibilities, and I don't think that raw ML processes are still needed. Are
there genuine counter examples to this claim?
datatype 'a trm = App "'a trm" "'a trm" | Const string | Var 'a

App (App (Const ''LE'') (Var x)) (Var y)

lift_definition trm_of_order_trm :: "'a order_trm ⇒ 'a trm" is id .

theory Scratch imports Main
begin

datatype 'a trm = App "'a trm" "'a trm" | Const string | Var 'a

fun is_order_trm :: "'a trm ⇒ bool" where
"is_order_trm (App (App (Const c) (Var x)) (Var y)) ⟷ c = ''LE'' ∨ c = ''LT'' ∨ c = ''EQ''" |
"is_order_trm _ ⟷ False"

typedef 'a order_trm = "{t::'a trm. is_order_trm t}"
  by (metis is_order_trm.simps(1) mem_Collect_eq)
setup_lifting type_definition_order_trm

abbreviation (input) "App2ConstVars c x y ≡ (App (App ((Const c)) (Var x)) (Var y))"
abbreviation (input) "CtorOrder c x y ≡ Abs_order_trm (App2ConstVars c x y)"
definition "CtorLE ≡ CtorOrder ''LE''"
definition "CtorLT ≡ CtorOrder ''LT''"
definition "CtorEQ ≡ CtorOrder ''EQ''"

lemmas order_ctor_defs = CtorLE_def CtorLT_def CtorEQ_def

lemma order_trm_cases:
  fixes t :: "'a order_trm"
  obtains
    (LE) x y where "t = CtorLE x y"
  | (LT) x y where "t = CtorLT x y"
  | (EQ) x y where "t = CtorEQ x y"
proof(cases t)
  case (Abs_order_trm t')
  then have "is_order_trm t'"
    by simp
  then show ?thesis using that Abs_order_trm
    apply(induction t' rule: is_order_trm.induct)
    by (auto simp: order_ctor_defs)
qed

lift_definition trm_of_order_trm :: "'a order_trm ⇒ 'a trm" is id .

free_constructors case_order_trm for
  "CtorLE" | "CtorLT" | "CtorEQ"
  apply(fact order_trm_cases)
  by (auto simp: order_ctor_defs Abs_order_trm_inject)

text ‹I want to define functions on @{typ "'a order_trm"} using pattern matching›
fun sem :: "'a rel ⇒ 'a order_trm ⇒ bool" where
"sem r (CtorLE x y) ⟷ (x, y) ∈ r" |
"sem r (CtorLT x y) ⟷ (x, y) ∈ r ∧ x ≠ y" |
"sem r (CtorEQ x y) ⟷ x = y"

definition "Sem r A ≡ (∀t ∈ A. sem r t)"

lemma "¬ Sem r {CtorLT x y, CtorEQ x y}"
  unfolding Sem_def
  by simp

text ‹
  Exporting code only works if I prove the following code equation manually.
  Can it be derived automatically?
›
lemma [code]:
  "Rep_order_trm t = (case t of
                       CtorLE x y ⇒ App2ConstVars ''LE'' x y
                     | CtorLT x y ⇒ App2ConstVars ''LT'' x y
                     | CtorEQ x y ⇒ App2ConstVars ''EQ'' x y)"
  by (auto split: order_trm.splits simp: Abs_order_trm_inverse order_ctor_defs)

export_code sem trm_of_order_trm in SML

value "Sem {(1::nat, 2)} {(CtorEQ 1 2), (CtorLT 1 2)}"

My scala-isabelle library currently uses 'isabelle process'. It uses it in the
following way:

  * From a Scala application, the Isabelle process is invoked with '-e
    somefile.ML' where somefile.ML contains a loop that reads commands from
    one named pipe (or socket in Windows) and writes responses asynchronously
    to another named pipe (or socket).

The proper way to invoke an Isabelle ML process in Scala is is via
isabelle.ML_Process() --- it has a lot of flexibility. At the same time I
reckon that this approach will not do the job, because it is not connected
properly to Isabelle/Scala via the PIDE protocol.
  override def startIsabelleProcess(cwd: Path, mlCode: String, logic: String,
                                    sessionRoots: Array[Path], build: Boolean,
                                    userDir: Optional[Path]): Process = {

    Isabelle_System.init(isabelle_root = isabelleRoot.toString)
    val channel = System_Channel()
    val options = Options.init()
    val channel_options = options.string.update("system_channel_address", channel.address).
      string.update("system_channel_password", channel.password)

    val sessionRoots2 = sessionRoots.map(p => isabelle.Path.explode(p.toString)).toList
    val sessions_structure = Sessions.load_structure(options = options, dirs = sessionRoots2)
    val store = Sessions.store(options)

    if (build) {
      Isabelle_Thread.fork(name = "Build Isabelle", daemon = true) {
        Build.build_logic(options = options, logic = logic, build_heap = true, dirs = sessionRoots2)
      }.join()
    }

    ML_Process(channel_options, sessions_structure, store, eval_main = mlCode, logic = logic, cwd = cwd.toFile)
  }

val userDir2 = isabelle.File.standard_path(userDir.get().toString)
val putenv = Class.forName("org.gjt.sp.jedit.MiscUtilities")
  .getMethod("putenv", classOf[String], classOf[String])
putenv.invoke(null, "ISABELLE_HOME_USER", userDir2)
putenv.invoke(null, "USER_HOME", userDir2)

  * I do not want to use the PIDE protocol for communication between the Scala
    application and scala-isabelle (but instead my own binary protocol).
    (Because I got a factor 1000 or so in round-trip time when switching to my
    own minimalistic RPC protocol compared to libisabelle that used PIDE.)

Afterwards, the measured roundtrip for Scala.function is approx. 0..2ms.
/----------- *.thy ------------------------------------
keywords "Example" :: thy_load (isac_example)
val _ =                                                  
  Outer_Syntax.command \<^command_keyword>‹Example› 
    "start a Calculation from a Formalise-file"
    (Resources.provide_parse_files (Command_Span.extensions ["str"]) -- Parse.parname
      >> (Toplevel.theory o (Preliminary.load_formalisation ParseC.formalise)));
\---------- *.thy ------------------------------------
/----------- isac.scala ------------------------------
package isabelle.isac
import isabelle._
object ISAC
{ class Load_Command1 extends Command_Span.Load_Command("isac_example")
  { override val extensions: List[String] = List("str") }
}
\---------- isac.scala ------------------------------

	Unknown load command specification: "isac_example"

   	keywords "spark_open" :: thy_load (spark_siv)

   ~$ grep -r spark_siv src/HOL/SPARK/
   src/HOL/SPARK/SPARK_Setup.thy:    and "spark_open" :: thy_load (spark_siv)
   src/HOL/SPARK/Tools/spark.scala:  class Load_Command2 extends Command_Span.Load_Command("spark_siv")

On 08/03/2021 14:35, Walther Neuper wrote:

... so the question: where / how is the constant spark_siv defined ?

You need to declare your add-ons to Isabelle/Scala formally via
isabelle_scala_service in etc/settings, e.g. see
https://isabelle.sketis.net/repos/isabelle-release/file/Isabelle2021/src/HOL/SPARK/etc/settings
An alternative is to ignore the whole thing and merely use literal file names
with explicit extension. E.g. see my change to 'boogie_file' for Isabelle2021:
https://isabelle.sketis.net/repos/isabelle-release/rev/b808eddc83cf
    keywords "Example" :: thy_load

    Example ‹/usr/local/isabisac/src/Tools/isac/Examples/exp_Statics_Biegel_Timischl_7-70.str›
    ./bin/isabelle build -v -b Isac

    Isac FAILED
    (see also /home/wneuper/.isabelle/isabisac/heaps/polyml-5.8.2_x86_64_32-linux/log/Isac)
    *** Failed to load theory "Isac.BridgeJEdit" (unresolved "Isac.Calculation")
    *** Failed to load theory "Isac.Build_Isac" (unresolved "Isac.BridgeJEdit")
    *** No such file: "/usr/local/isabisac/src/Tools/isac/Examples/exp_Statics_Biegel_Timischl_7-70.str.str" (line 230 of "~~/src/Tools/isac/BridgeJEdit/Calculation.thy")
    *** At command "Example" (line 230 of "~~/src/Tools/isac/BridgeJEdit/Calculation.thy")
    Unfinished session(s): Isac

val ctxt =3D Con=
text("HOL.Imperative_HOL.ex.Imperative_Quicksort")=0A=
=0A=
import net.liftweb.json._=0A=
import net.liftweb.json.Serialization.write=0A=
=0A=
implicit val formats =3D net.liftweb.json.De=
faultFormatsval jsonString =3D write(ctxt)=0A=
println("before jsonString")=0A=
println(jsonString)=0A=
println("after jsonString")
before jsonString=0A=
{"mlValue":{"id":{"=
;_fun":{},"_ec":{},"_arg"=
;:null,"_xform":2}=
}}=0A=
after jsonString
val ctxt =
=3D Context("HOL.Imperative_HOL.ex.Imp=
erative_Quicksort")=0A=
=0A=
import net.liftw=
eb.json._=0A=
import net.liftw=
eb.json.Serialization.write=0A=
=0A=
implicit val formats =3D net.lif=
tweb.json.DefaultFormatsval jsonStr=
ing =3D write(ctxt)=0A=
println("before jso=
nString")=0A=
println(jsonString)=0A=
println("after json=
String")
before jsonString=0A=
{"mlValue":{"id":{"_fun":{},"_ec":{},"_arg"=
;:null,"_xform":=
2}}}=0A=
after jsonString
val ctxt = Context("HOL.Imperative_HOL.ex.Imperative_Quicksort")

import net.liftweb.json._
import net.liftweb.json.Serialization.write

implicit val formats = net.liftweb.json.DefaultFormatsval jsonString = write(ctxt)
println("before jsonString")
println(jsonString)
println("after jsonString")
before jsonString
{"mlValue":{"id":{"_fun":{},"_ec":{},"_arg":null,"_xform":2}}}
after jsonString
+ isabelle-session:=0A=
  - HOL
tomr at DESKTOP /cygdrive/c/Homes/Is=
abelle2021/Isabelle2021=0A=
$ isabelle export -O /cygdrive/c/test -x *:**  HOL