WIP update to use InterTypes

Project.toml

@@ -11,13 +11,15 @@ Decapodes = "679ab3ea-c928-4fe6-8d59-fd451142d391"
 JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
 MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
+OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
+Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
 
 [compat]
 ACSets = "0.2"
 Catlab = "0.15, 0.16"
-Decapodes = "0.5"
+Decapodes = "0.4, 0.5"
 JSON = "0.21"
 JSON3 = "1"
 MLStyle = "0.4"

docs/Project.toml

@@ -6,5 +6,6 @@ Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
 Literate = "98b081ad-f1c9-55d3-8b20-4c87d4299306"
 MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
+OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
 SyntacticModels = "22bb929c-8bcf-4852-b455-eb3e1675e09c"

src/amr.it

@@ -0,0 +1,102 @@
+
+@sum Args begin
+  Value(_1::Symbol)
+  Kwarg(_1::Symbol, _2::Args)
+end
+
+struct Statement
+  table::Symbol
+  element::Vector{Args}
+end
+
+#=
+@sum union_sym_expr begin
+  sym(s::Symbol)
+  expr(e::Expr)
+end
+=#
+
+struct ACSetSpec
+  acstype::Symbol
+  body::Vector{Statement}
+end
+
+@sum MathML begin
+  Math(str::String)
+  Presentation(str::String)
+end
+
+
+struct ExpressionFormula
+  expression::String
+  expression_mathml::MathML
+end
+
+struct Unit
+  expression::String
+  expression_mathml::MathML
+end
+
+
+@sum Distribution begin
+  StandardUniform(str::String)
+  Uniform(min::Float64, max::Float64)
+  StandardNormal(str::String)
+  Normal(mean::Float64, variance::Float64)
+  PointMass(value::Float64)
+end
+
+struct Observable
+  id::Symbol
+  name::String
+  states::Vector{Symbol}
+  f::ExpressionFormula
+end
+
+@sum Expression begin
+  Rate(target::Symbol, f::ExpressionFormula)
+  Initial(target::Symbol, f::ExpressionFormula)
+  Parameter(id::Symbol, name::String, description::String, units::Unit, value::Float64, distribution::Distribution)
+  Time(id::Symbol, units::Unit)
+end
+
+struct Pair
+  first::Symbol
+  second::Symbol
+end
+
+@sum Semantic begin
+  ODEList(statements::Vector{Expression})
+  ODERecord(rates::Vector{Rate}, initials::Vector{Initial}, parameters::Vector{Parameter}, time::Time)
+  Typing(system::ACSetSpec, map::Vector{Pair})
+end
+
+
+@sum Note begin
+  Name(str::String)
+  Description(str::String)
+  Grounding(ontology::String, identifier::String)
+  Units(expression::String)
+end
+
+struct Annotation
+  entity::Symbol
+  type::Symbol
+  note::Note
+end
+
+struct Header
+  id::String
+  name::String
+  schema::String
+  description::String
+  schema_name::String
+  model_version::String
+end
+
+
+struct ASKEModel
+  header::Header 
+  model::ACSetSpec
+  semantics::Vector{Semantic}
+end

src/amr.jl

@@ -1,10 +1,10 @@
 module AMR
 
-export Math, MathML, ExpressionFormula, Unit, Distribution, Observable, Expression,
+export amr, Math, MathML, ExpressionFormula, Unit, Distribution, Observable, Expression,
  Rate, Initial, Parameter, Time,
  StandardUniform, Uniform, StandardNormal, Normal, PointMass,
- Semantic, Header, ODERecord, ODEList, Typing, ASKEModel,
- distro_string, amr_to_string,
+ Semantic, Header, ODERecord, ODEList, ASKEModel, # Typing, 
+ distro_string, # amr_to_string,
  Annotation, Note, Name, Description, Grounding, Units
 
 using Reexport
@@ -14,104 +14,28 @@
 using ACSets.ACSetInterface
 using StructTypes
 
-using ..SyntacticModelsBase
 
-@data MathML <: AbstractTerm begin
-  Math(String)
-  Presentation(String)
-end
-
-nomath = Math("")
-
-@as_record struct ExpressionFormula{T} <: AbstractTerm
-  expression::T
-  expression_mathml::MathML
-end
-
-@as_record struct Unit <: AbstractTerm
-  expression::String
-  expression_mathml::MathML
-end
+@intertypes "amr.it" module amr end
 
+using .amr
 
-nounit = Unit("", nomath)
-
-@data Distribution <: AbstractTerm begin
-  StandardUniform
-  Uniform(min, max)
-  StandardNormal
-  Normal(mean, variance)
-  PointMass(value)
-end
 
-@as_record struct Observable{T <: AbstractTerm}
-  id::Symbol
-  name::String
-  states::Vector{Symbol}
-  f::ExpressionFormula
-end
-
-@data Expression <: AbstractTerm begin
-  Rate(target::Symbol, f::ExpressionFormula)
-  Initial(target::Symbol, f::ExpressionFormula)
-  Parameter(id::Symbol, name::String, description::String, units::Unit, value::Float64, distribution::Distribution)
-  Time(id::Symbol, units::Unit)
-end
-
-@data Semantic  <: AbstractTerm begin
-  ODEList(statements::Vector{Expression})
-  ODERecord(rates::Vector{Rate}, initials::Vector{Initial}, parameters::Vector{Parameter}, time::Time)
-  # Metadata
-  Typing(system::ACSetSpec, map::Vector{Pair})
-  # Stratification
-end
-
-@data Note <: AbstractTerm begin
-  Name(str::String)
-  Description(str::String)
-  Grounding(ontology::String, identifier::String)
-  Units(expression::String)
-end
-
-StructTypes.StructType(::Type{Note}) = StructTypes.AbstractType()
-StructTypes.subtypekey(::Type{Note}) = :_type
-StructTypes.subtypes(::Type{Note}) =
-  (Name=Name,Description=Description,Grounding=Grounding,Units=Units,)
-
-@as_record struct Annotation{E,T} <: AbstractTerm
-  entity::E
-  type::T
-  note::Note
-end
-
-@as_record struct Header <: AbstractTerm
-  name::String
-  schema::String
-  description::String
-  schema_name::String
-  model_version::String
-end
-
-@as_record struct ASKEModel <: AbstractTerm
-  header::Header 
-  model::ACSetSpec
-  semantics::Vector{Semantic}
-end
-
-function distro_string(d::Distribution)
+function distro_string(d::amr.Distribution)
   @match d begin
-    StandardUniform   => "U(0,1)"
-    Uniform(min, max) => "U($min,$max)"
-    StandardNormal    => "N(0,1)"
-    Normal(mu, var)   => "N($mu,$var)"
-    PointMass(value)  => "δ($value)"
+    amr.StandardUniform(s)   => "U(0,1)"
+    amr.Uniform(min, max) => "U($min,$max)"
+    amr.StandardNormal(s)    => "N(0,1)"
+    amr.Normal(mu, var)   => "N($mu,$var)"
+    amr.PointMass(value)  => "δ($value)"
   end
 end
 
-function distro_expr(d::Distribution)
+function distro_expr(d::amr.Distribution)
   return Base.Meta.parse(distro_string(d))
 end
 
+#=
+
 function note_string(n::Note)
   @match n begin
     Name(n)           => "Name($n)"
@@ -129,34 +53,34 @@
   " "^n * s
 end
 padlines(s::String, n=2) = join(padlines(split(s, "\n"), n), "\n")
-
-function amr_to_string(amr)
+=#
+function amr_to_string(amr′)
   let ! = amr_to_string
-    @match amr begin
-      s::String                        => s
-      Math(s)                          => !s
-      Presentation(s)                  => "<mathml> $s </mathml>"
-      u::Unit                          => !u.expression
-      d::Distribution                  => distro_string(d)
-      Time(id, u)                      => "$id::Time{$(!u)}\n"
-      Rate(t, f)                       => "$t::Rate = $(f.expression)"
-      Initial(t, f)                    => "$t::Initial = $(f.expression)"
-      Observable(id, n, states, f)     => "# $n\n$id::Observable = $(f.expression)($states)\n"
-      Header(name, s, d, sn, mv)       => "\"\"\"\nASKE Model Representation: $name$mv :: $sn \n   $s\n\n$d\n\"\"\""
-      Parameter(t, n, d, u, v, dist)   => "\n# $n-- $d\n$t::Parameter{$(!u)} = $v ~ $(!dist)\n"
+    @match amr′ begin
+      s::String                            => s
+      amr.Math(s)                          => !s
+      amr.Presentation(s)                  => "<mathml> $s </mathml>"
+      u::amr.Unit                          => !u.expression
+      d::amr.Distribution                  => distro_string(d)
+      amr.Time(id, u)                      => "$id::Time{$(!u)}\n"
+      amr.Rate(t, f)                       => "$t::Rate = $(f.expression)"
+      amr.Initial(t, f)                    => "$t::Initial = $(f.expression)"
+      amr.Observable(id, n, states, f)     => "# $n\n$id::Observable = $(f.expression)($states)\n"
+      amr.Header(id, name, s, d, sn, mv)   => "\"\"\"\nASKE Model Representation: $name$mv :: $sn \n   $s\n\n$d\n\"\"\""
+      amr.Parameter(t, n, d, u, v, dist)   => "\n# $n-- $d\n$t::Parameter{$(!u)} = $v ~ $(!dist)\n"
       m::ACSetSpec                     => "Model = begin\n$(padlines(sprint(show, m),2))\nend"
-      ODEList(l)                       => "ODE_Equations = begin\n" * padlines(join(map(!, l), "\n")) * "\nend"
-      ODERecord(rts, init, para, time) => join(vcat(["ODE_Record = begin\n"], !rts , !init, !para, [!time, "end"]), "\n")
-      vs::Vector{Pair}                 => map(vs) do v; "$(v[1]) => $(v[2])," end |> x-> join(x, "\n") 
-      vs::Vector{Semantic}             => join(map(!, vs), "\n\n")
+      amr.ODEList(l)                       => "ODE_Equations = begin\n" * padlines(join(map(!, l), "\n")) * "\nend"
+      amr.ODERecord(rts, init, para, time) => join(vcat(["ODE_Record = begin\n"], !rts , !init, !para, [!time, "end"]), "\n")
+      vs::Vector{amr.Pair}                 => map(vs) do v; "$(v[1]) => $(v[2])," end |> x-> join(x, "\n") 
+      vs::Vector{amr.Semantic}             => join(map(!, vs), "\n\n")
       xs::Vector                       => map(!, xs)
-      Typing(system, map)              => "Typing = begin\n$(padlines(!system, 2))\nTypeMap = [\n$(padlines(!map, 2))]\nend"
-      ASKEModel(h, m, s)               => "$(!h)\n$(!m)\n\n$(!s)"
-      Annotation(e,t,n)                => "Annotation = $(String(e)),$(String(t)): $(note_string(n))"
+      # amr.Typing(system, map)              => "Typing = begin\n$(padlines(!system, 2))\nTypeMap = [\n$(padlines(!map, 2))]\nend"
+      # amr.ASKEModel(h, m, s)               => "$(!h)\n$(!m)\n\n$(!s)"
+      amr.Annotation(e,t,n)                => "Annotation = $(String(e)),$(String(t)): $(note_string(n))"
     end
   end
 end
-
+#=
 block(exprs) = begin
   q = :(begin
 
@@ -167,6 +91,7 @@
 
 extract_acsetspec(s::String) = join(split(s, " ")[2:end], " ") |> Meta.parse
 
+
 function amr_to_expr(amr)
   let ! = amr_to_expr
     @match amr begin
@@ -460,4 +385,5 @@
   end
   ASKEModel(elts[2][1], elts[2][2], [elts[4], elts[6]])
 end
+=#
 end # module end

src/composite_models.it

@@ -0,0 +1,6 @@
+
+@sum CompositeModel begin
+  OpenModel(model::decapodes.ASKEMDecaExpr, interface::Vector{Symbol})
+  OpenDecapode(model::decapodes.ASKEMDecapode, interface::Vector{Symbol})
+  CompositeModelExpr(header::amr.Header, composition_pattern::uwd.UWDExpr, components::Vector{CompositeModel})
+end