Restructure Model type and usage of its type arguments, esp. missings

Author: phipsgabler

src/DynamicPPL.jl

@@ -62,7 +62,11 @@ export  VarName,
         set_resume!,
 # Model
         Model,
-        getmissing,
+        getmissings,
+        getargnames,
+        getdefaults,
+        getgenerator,
+        getmodeltype,
         runmodel!,
 # Samplers
         Sampler,

src/compiler.jl

@@ -321,7 +321,7 @@ function generate_tilde(left, right, model_info)
         ex = quote
             $temp_right = $right
             $assert_ex
-            $preprocessed = DynamicPPL.@preprocess($arg_syms, DynamicPPL.getmissing($model), $left)
+            $preprocessed = DynamicPPL.@preprocess($arg_syms, Val{DynamicPPL.getmissings($model)}(), $left)
             if $preprocessed isa Tuple
                 $vn, $inds = $preprocessed
                 $out = DynamicPPL.tilde($ctx, $sampler, $temp_right, $vn, $inds, $vi)
@@ -370,7 +370,7 @@ function generate_dot_tilde(left, right, model_info)
         ex = quote
             $temp_right = $right
             $assert_ex
-            $preprocessed = DynamicPPL.@preprocess($arg_syms, DynamicPPL.getmissing($model), $left)
+            $preprocessed = DynamicPPL.@preprocess($arg_syms, Val{DynamicPPL.getmissings($model)}(), $left)
             if $preprocessed isa Tuple
                 $vn, $inds = $preprocessed
                 $temp_left = $left
@@ -452,19 +452,13 @@ function build_output(model_info)
     end
 
     modelgen_kw_form = isempty(args) ? () : (:($model_gen(;$(args...)) = $model_gen($(arg_syms...))),)
-    missings = gensym(:missings)
-    args_tuple = gensym(:args_tuple)
+    model_type = :(DynamicPPL.Model{typeof($model_gen), $(Tuple(arg_syms))})
 
     ex = quote
-        function $model_gen($(args...))
-            $args_tuple = $args_nt
-            $missings = DynamicPPL.getmissing($args_tuple)
-            return DynamicPPL.Model{typeof($model_gen)}($args_tuple, $missings)
-        end
-        
+        $model_gen($(args...)) = DynamicPPL.Model{typeof($model_gen)}($args_nt)
         $(modelgen_kw_form...)
 
-        function ($model::DynamicPPL.Model{typeof($model_gen)})(
+        function ($model::$model_type)(
             $vi::DynamicPPL.VarInfo,
             $sampler::DynamicPPL.AbstractSampler,
             $ctx::DynamicPPL.AbstractContext,
@@ -474,10 +468,9 @@ function build_output(model_info)
             $main_body
         end
 
-        DynamicPPL.getdefaults(::typeof($model_gen)) = $defaults_nt
-        DynamicPPL.getargnames(::typeof($model_gen)) = $(Tuple(arg_syms))
-        DynamicPPL.getmodeltype(::typeof($model_gen)) = DynamicPPL.Model{typeof($model_gen)}
-        DynamicPPL.getgenerator(::DynamicPPL.Model{typeof($model_gen)}) = $model_gen
+        DynamicPPL.getmodeltype(::typeof($model_gen)) = $model_type
+        DynamicPPL.getgenerator(::Type{<:$model_type}) = $model_gen
+        DynamicPPL.getdefaults(::Type{<:$model_type}) = $defaults_nt
     end
 
     return esc(ex)

src/model.jl

@@ -1,62 +1,80 @@
 """
-    struct Model{G, Targs<:NamedTuple, Tmissings <: Val}
-        args::Targs
-        missings::Tmissings
+    struct Model{G, argnames, missings, Targs}
+        args::NamedTuple{argnames, Targs}
     end
 
-A `Model` struct with arguments `args`, model generator type `G` and
-missing data `missings`. `missings` is a `Val` instance, e.g. `Val{(:a, :b)}()`. An
-argument in `args` with a value `missing` will be in `missings` by default. However, in
-non-traditional use-cases `missings` can be defined differently. All variables in
-`missings` are treated as random variables rather than observations.
+A `Model` struct with model generator type `G`, arguments names `argnames`, arguments types `Targs`,
+and missing arguments `missings`. `argnames` and `missings` are tuples of symbols, e.g. `(:a,
+:b)`.  An argument with a type of `Missing` will be in `missings` by default.  However, in
+non-traditional use-cases `missings` can be defined differently.  All variables in `missings` are
+treated as random variables rather than observations.
+
+# Example
+
+```julia
+julia> Model{typeof(gdemo)}((x = 1.0, y = 2.0))
+Model{typeof(gdemo),(),(:x, :y),Tuple{Float64,Float64}}((x = 1.0, y = 2.0))
+
+julia> Model{typeof(gdemo), (:y,)}((x = 1.0, y = 2.0))
+Model{typeof(gdemo),(:y,),(:x, :y),Tuple{Float64,Float64}}((x = 1.0, y = 2.0))
+```
 """
-struct Model{G, Targs<:NamedTuple, Tmissings<:Val} <: AbstractModel
-    args::Targs
-    missings::Tmissings
+struct Model{G, argnames, missings, Targs} <: AbstractModel
+    args::NamedTuple{argnames, Targs}
+
+    Model{G, missings}(args::NamedTuple{argnames, Targs}) where {G, argnames, missings, Targs} =
+        new{G, argnames, missings, Targs}(args)
+end
+
+@generated function Model{G}(args::NamedTuple{argnames, Targs}) where {G, argnames, Targs}
+    missings = Tuple(name for (name, typ) in zip(argnames, Targs.types) if typ <: Missing)
+    return :(Model{G, $missings}(args))
 end
 
-Model{G}(args::Targs, missings::Tmissings) where {G, Targs, Tmissings} =
-    Model{G, Targs, Tmissings}(args, missings)
 
 (model::Model)(vi) = model(vi, SampleFromPrior())
 (model::Model)(vi, spl) = model(vi, spl, DefaultContext())
 
 
 """
-    getgenerator(model::Model)
+    getargnames(model::Model)
 
-Get the generator (the function defined by the `@model` macro) of a certain model instance.
+Get a tuple of the argument names of the `model`.
 """
-function getgenerator end
+getargnames(model::Model) = getargnames(typeof(model))
+getargnames(::Type{<:Model{_G, argnames} where {_G}}) where {argnames} = argnames
+
 
 """
-    getmodeltype(::typeof(modelgen))
+    getmissings(model::Model)
 
-Get the associated model type for a model generating function.
+Get a tuple of the names of the missing arguments of the `model`.
 """
-function getmodeltype end
+getmissings(model::Model{_G, _a, missings}) where {missings, _G, _a} = missings
+
+getmissing(model::Model) = getmissings(model)
+@deprecate getmissing(model) getmissings(model)
+
 
 """
-    getdefaults(::typeof(modelgen))
+    getgenerator(model::Model)
 
-Get a named tuple of the default argument values defined for a model defined by a generating function.
+Get the generator (the function defined by the `@model` macro) of a certain model instance.
 """
-function getdefaults end
+getgenerator(model::Model) = getgenerator(typeof(model))
+
 
 """
-    getargnames(::typeof(modelgen))
+    getdefaults(model::Model)
 
-Get a tuple of the argument names of the model defined by a generating function.
+Get a named tuple of the default argument values defined for a model defined by a generating function.
 """
-function getargnames end
+getdefaults(model::Model) = getdefaults(typeof(model))
 
 
-getmissing(model::Model) = model.missings
-@generated function getmissing(args::NamedTuple{names, ttuple}) where {names, ttuple}
-    length(names) == 0 && return :(Val{()}())
-    minds = filter(1:length(names)) do i
-        ttuple.types[i] == Missing
-    end
-    mnames = names[minds]
-    return :(Val{$mnames}())
-end
+"""
+    getmodeltype(::typeof(modelgen))
+
+Get the associated model type for a model generator (the function defined by the `@model` macro).
+"""
+getmodeltype(model::Model) = typeof(model)