Remove ModelGen

Author: devmotion

src/DynamicPPL.jl

@@ -51,25 +51,20 @@ export  AbstractVarInfo,
         inspace,
         subsumes,
 # Compiler
-        ModelGen,
         @model,
         @varname,
 # Utilities
         vectorize,
         reconstruct,
         reconstruct!,
         Sample,
-        Chain,
         init,
         vectorize,
         set_resume!,
 # Model
-        ModelGen,
         Model,
         getmissings,
         getargnames,
-        getdefaults,
-        getgenerator,
 # Samplers
         Sampler,
         SampleFromPrior,

src/compiler.jl

@@ -330,7 +330,7 @@ function build_output(model_info)
     # Where parameters
     whereparams = model_info[:whereparams]
     # Model generator name
-    model_gen = model_info[:name]
+    model = model_info[:name]
     # Main body of the model
     main_body = model_info[:main_body]
 
@@ -340,26 +340,26 @@ function build_output(model_info)
               :($var = $(DynamicPPL.matchingvalue)(_sampler, _varinfo, _model.args.$var)))
     end
 
-    @gensym(evaluator, generator)
-    generator_kw_form = isempty(args) ? () : (:($generator(;$(args...)) = $generator($(arg_syms...))),)
-    model_gen_constructor = :($(DynamicPPL.ModelGen){$(Tuple(arg_syms))}($generator, $defaults_nt))
+    model_kwform = isempty(args) ? () : (:($model(;$(args...)) = $model($(arg_syms...))),)
+    @gensym(evaluator)
 
     return quote
-        function $evaluator(
-            _rng::$(Random.AbstractRNG),
-            _model::$(DynamicPPL.Model),
-            _varinfo::$(DynamicPPL.AbstractVarInfo),
-            _sampler::$(DynamicPPL.AbstractSampler),
-            _context::$(DynamicPPL.AbstractContext),
-        )
-            $unwrap_data_expr
-            $main_body
+        $(Base).@__doc__ function $model($(args...))
+            $evaluator = let
+                function (
+                    _rng::$(Random.AbstractRNG),
+                    _model::$(DynamicPPL.Model),
+                    _varinfo::$(DynamicPPL.AbstractVarInfo),
+                    _sampler::$(DynamicPPL.AbstractSampler),
+                    _context::$(DynamicPPL.AbstractContext),
+                )
+                    $unwrap_data_expr
+                    $main_body
+                end
+            end
+            return $(DynamicPPL.Model)($evaluator, $args_nt, $defaults_nt)
         end
-
-        $generator($(args...)) = $(DynamicPPL.Model)($evaluator, $args_nt, $model_gen_constructor)
-        $(generator_kw_form...)
-
-        $(Base).@__doc__ $model_gen = $model_gen_constructor
+        $(model_kwform...)
     end
 end
 

src/model.jl

@@ -1,112 +1,70 @@
 """
-    struct ModelGen{G, defaultnames, Tdefaults}
-        generator::G
-        defaults::Tdefaults
-    end
-
-A `ModelGen` struct with model generator function of type `G`, and default arguments `defaultnames`
-with values `Tdefaults`.
-"""
-struct ModelGen{G, argnames, defaultnames, Tdefaults}
-    generator::G
-    defaults::NamedTuple{defaultnames, Tdefaults}
-
-    function ModelGen{argnames}(
-        generator::G,
-        defaults::NamedTuple{defaultnames, Tdefaults}
-    ) where {G, argnames, defaultnames, Tdefaults}
-        return new{G, argnames, defaultnames, Tdefaults}(generator, defaults)
+    struct Model{F,argnames,defaultnames,missings,Targs,Tdefaults}
+        f::F
+        args::NamedTuple{argnames,Targs}
+        defaults::NamedTuple{defaultnames,Tdefaults}
     end
-end
-
-(m::ModelGen)(args...; kwargs...) = m.generator(args...; kwargs...)
-
-
-"""
-    getdefaults(modelgen::ModelGen)
-
-Get a named tuple of the default argument values defined for a model defined by a generating function.
-"""
-getdefaults(modelgen::ModelGen) = modelgen.defaults
-
-"""
-    getargnames(modelgen::ModelGen)
-
-Get a tuple of the argument names of the `modelgen`.
-"""
-getargnames(model::ModelGen{_G, argnames}) where {argnames, _G} = argnames
 
+A `Model` struct with model evaluation function of type `F`, arguments of names `argnames`
+types `Targs`, default arguments of names `defaultnames` with types `Tdefaults`, and missing
+arguments `missings`.
 
+Here `argnames`, `defaultargnames`, and `missings` are tuples of symbols, e.g. `(:a, :b)`.
 
-"""
-    struct Model{F, argnames, Targs, missings}
-        f::F
-        args::NamedTuple{argnames, Targs}
-        modelgen::Tgen
-    end
+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.
 
-A `Model` struct with model evaluation function of type `F`, arguments names `argnames`, arguments
-types `Targs`, missing arguments `missings`, and corresponding model generator. `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.
+The default arguments are used internally when constructing instances of the same model with
+different arguments.
 
-# Example
+# Examples
 
 ```julia
 julia> Model(f, (x = 1.0, y = 2.0))
-Model{typeof(f),(),(:x, :y),Tuple{Float64,Float64}}((x = 1.0, y = 2.0))
+Model{typeof(f),(:x, :y),(),(),Tuple{Float64,Float64},Tuple{}}(f, (x = 1.0, y = 2.0), NamedTuple())
+
+julia> Model(f, (x = 1.0, y = 2.0), (x = 42,))
+Model{typeof(f),(:x, :y),(:x,),(),Tuple{Float64,Float64},Tuple{Int64}}(f, (x = 1.0, y = 2.0), (x = 42,))
 
-julia> Model{(:y,)}(f, (x = 1.0, y = 2.0))
-Model{typeof(f),(:y,),(:x, :y),Tuple{Float64,Float64}}((x = 1.0, y = 2.0))
+julia> Model{(:y,)}(f, (x = 1.0, y = 2.0), (x = 42,))
+Model{typeof(f),(:x, :y),(:x,),(:y,),Tuple{Float64,Float64},Tuple{Int64}}(f, (x = 1.0, y = 2.0), (x = 42,))
 ```
 """
-struct Model{F, argnames, Targs, missings, Tgen} <: AbstractModel
+struct Model{F,argnames,defaultnames,missings,Targs,Tdefaults} <: AbstractModel
     f::F
-    args::NamedTuple{argnames, Targs}
-    modelgen::Tgen
+    args::NamedTuple{argnames,Targs}
+    defaults::NamedTuple{defaultnames,Tdefaults}
 
     """
-        Model{missings}(f, args::NamedTuple, modelgen::ModelGen)
+        Model{missings}(f, args::NamedTuple, defaults::NamedTuple)
 
-    Create a model with evalutation function `f` and missing arguments overwritten by `missings`.
+    Create a model with evaluation function `f` and missing arguments overwritten by `missings`.
     """
     function Model{missings}(
         f::F,
-        args::NamedTuple{argnames, Targs},
-        modelgen::Tgen
-    ) where {missings, F, argnames, Targs, Tgen<:ModelGen}
-        return new{F, argnames, Targs, missings, Tgen}(f, args, modelgen)
+        args::NamedTuple{argnames,Targs},
+        defaults::NamedTuple{defaultnames,Tdefaults},
+    ) where {missings,F,argnames,Targs,defaultnames,Tdefaults}
+        return new{F,argnames,defaultnames,missings,Targs,Tdefaults}(f, args, defaults)
     end
 end
 
 """
-    Model(f, args::NamedTuple, modelgen::ModelGen)
+    Model(f, args::NamedTuple[, defaults::NamedTuple = ()])
 
-    Create a model with evalutation function `f` and missing arguments deduced from `args`.
+Create a model with evaluation function `f` and missing arguments deduced from `args`.
+
+Default arguments `defaults` are used internally when constructing instances of the same
+model with different arguments.
 """
 @generated function Model(
     f::F,
-    args::NamedTuple{argnames, Targs},
-    modelgen::ModelGen{_G, argnames}
-) where {F, argnames, Targs, _G}
+    args::NamedTuple{argnames,Targs},
+    defaults::NamedTuple = NamedTuple(),
+) where {F,argnames,Targs}
     missings = Tuple(name for (name, typ) in zip(argnames, Targs.types) if typ <: Missing)
-    return :(Model{$missings}(f, args, modelgen))
-end
-
-
-"""
-    Model{missings}(modelgen::ModelGen, args::NamedTuple)
-
-Create a copy of the model described by `modelgen(args...)`, with missing arguments 
-overwritten by `missings`.
-"""
-function Model{missings}(
-    modelgen::ModelGen,
-    args::NamedTuple{argnames, Targs}
-) where {missings, argnames, Targs}
-    model = modelgen(args...)
-    return Model{missings}(model.f, args, modelgen)
+    return :(Model{$missings}(f, args, defaults))
 end
 
 """
@@ -184,27 +142,19 @@ end
 
 Get a tuple of the argument names of the `model`.
 """
-getargnames(model::Model{_F, argnames}) where {argnames, _F} = argnames
+getargnames(model::Model{_F,argnames}) where {argnames,_F} = argnames
 
 
 """
     getmissings(model::Model)
 
 Get a tuple of the names of the missing arguments of the `model`.
 """
-getmissings(model::Model{_F, _a, _T, missings}) where {missings, _F, _a, _T} = missings
+getmissings(model::Model{_F,_a,_d,missings}) where {missings,_F,_a,_d} = missings
 
 getmissing(model::Model) = getmissings(model)
 @deprecate getmissing(model) getmissings(model)
 
-
-"""
-    getgenerator(model::Model)
-
-Get the model generator associated with `model`.
-"""
-getgenerator(model::Model) = model.modelgen
-
 """
     logjoint(model::Model, varinfo::AbstractVarInfo)