Simplify defaults

Author: phipsgabler

src/compiler.jl

@@ -173,6 +173,7 @@ function build_model_info(input_expr)
 
     model_info = Dict(
         :name => modeldef[:name],
+        :model_tag => gensym(modeldef[:name]),
         :main_body => modeldef[:body],
         :arg_syms => arg_syms,
         :args_nt => args_nt,
@@ -183,9 +184,7 @@ function build_model_info(input_expr)
             :ctx => gensym(:ctx),
             :vi => gensym(:vi),
             :sampler => gensym(:sampler),
-            :model => gensym(:model),
-            :model_function => gensym(modeldef[:name]),
-            :defaults => gensym(:defaults)
+            :model => gensym(:model)
         )
     )
 
@@ -432,6 +431,8 @@ function build_output(model_info)
     whereparams = model_info[:whereparams]
     # Model generator name
     model_gen = model_info[:name]
+    # Tag used for the model type
+    model_tag = model_info[:model_tag]
     # Main body of the model
     main_body = model_info[:main_body]
 
@@ -453,8 +454,7 @@ function build_output(model_info)
         end)
     end
 
-    model_type = :(DynamicPPL.Model{$(QuoteNode(model_function))})
-    defaults = gensym(:defaults)
+    model_type = :(DynamicPPL.Model{$(QuoteNode(model_tag))})
 
     ex = quote
         function ($model::$model_type)(
@@ -467,9 +467,8 @@ function build_output(model_info)
             $main_body
         end
 
-        $defaults = $defaults_nt
-        getdefaults(::$model_type) = $defaults
-        $model_gen($(args...)) = $model_type($args_nt, $defaults)
+        getdefaults(::$model_type) = $defaults_nt
+        $model_gen($(args...)) = $model_type($args_nt)
     end
 
     if !isempty(args)

src/model.jl

@@ -1,7 +1,6 @@
 """
-    struct Model{S, Targs<:NamedTuple, Tdefaults<:NamedTuple, Tmissings <: Val}
+    struct Model{S, Targs<:NamedTuple, Tmissings <: Val}
         args::Targs
-        defaults::Tdefaults
         missings::Tmissings
     end
 
@@ -11,27 +10,26 @@ argument in `args` with a value `missing` will be in `missings` by default. Howe
 non-traditional use-cases `missings` can be defined differently. All variables in
 `missings` are treated as random variables rather than observations.
 """
-struct Model{S, Targs<:NamedTuple, Tdefaults<:NamedTuple, Tmissings<:Val} <: AbstractModel
+struct Model{S, Targs<:NamedTuple, Tmissings<:Val} <: AbstractModel
     args::Targs
-    defaults::Tdefaults
     missings::Tmissings
 end
 
-function Model{S}(args::NamedTuple, defaults::NamedTuple) where {S}
+function Model{S}(args::NamedTuple) where {S}
     missings = getmissing(args)
-    Model{S, typeof(args), typeof(defaults), typeof(missings)}(args, defaults, missings)
+    Model{S, typeof(args), typeof(missings)}(args, missings)
 end
 
 (model::Model)(vi) = model(vi, SampleFromPrior())
 (model::Model)(vi, spl) = model(vi, spl, DefaultContext())
 
 
 """
-    getdefaults(::Type{<:Model})
+    getdefaults(model)
 
 Get a named tuple of the default argument values defined in a `Model` type.
 """
-function getdefaults end
+getdefaults(model::Model) = getdefaults(typeof(model))
 
 
 getargtype(::Type{<:Model{S, Targs}}) where {S, Targs} = Targs