Model-dispatching and Experimental submodule

src/DynamicPPL.jl

@@ -134,4 +134,6 @@ include("compat/ad.jl")
 include("loglikelihoods.jl")
 include("submodel_macro.jl")
 
+include("experimental/Experimental.jl")
+
 end # module

src/experimental/Experimental.jl

@@ -0,0 +1,51 @@
+module Experimental
+
+using ..DynamicPPL: DynamicPPL
+
+export modeltype
+
+"""
+    evaluatortype(f)
+    evaluatortype(f, nargs)
+    evaluatortype(f, argtypes)
+    evaluatortype(m::DynamicPPL.Model)
+
+Returns the evaluator-type for model `m` or a model-constructor `f`.
+
+(!!!) If you're using Revise.jl, remember that you might need to re-instaniate
+the model since `evaluatortype` might have changed.
+"""
+function evaluatortype(f, argtypes)
+    rets = Core.Compiler.return_types(f, argtypes)
+    if (length(rets) != 1) || !(first(rets) <: DynamicPPL.Model)
+        error(
+            "inferred return-type of $(f) using $(argtypes) is not `Model`; please specify argument types",
+        )
+    end
+    # Extract the anonymous evaluator.
+    return first(rets).parameters[1]
+end
+evaluatortype(f, nargs::Int) = evaluatortype(f, ntuple(_ -> Missing, nargs))
+function evaluatortype(f)
+    m = first(methods(f))
+    # Extract the arguments (first element is the method itself).
+    nargs = length(m.sig.parameters) - 1
+
+    return evaluatortype(f, nargs)
+end
+evaluatortype(::DynamicPPL.Model{F}) where {F} = F
+
+"""
+    modeltype(modeldef[, args...])
+    modeltype(model::Model)
+
+Return `Model{F}` where `F` is the type of the evaluator for `model`/`modeldef`.
+
+This is particularly useful for dispatching on models without instantiation.
+
+See [`evaluatortype`](@ref) for information on the additional `args` that can be passed.
+"""
+modeltype(modeldef, args...) = DynamicPPL.Model{evaluatortype(modeldef, args...)}
+modeltype(::DynamicPPL.Model{F}) where {F} = DynamicPPL.Model{F}
+
+end

test/experimental.jl

@@ -0,0 +1,25 @@
+using DynamicPPL.Experimental
+
+@testset "Experimental" begin
+    @testset "evaluatortype" begin
+        f(x) = false
+
+        @model demo() = x ~ Normal()
+        f(::modeltype(demo)) = true
+        @test f(demo())
+
+        # Leads to re-definition of `demo` with new body.
+        @model demo() = x ~ Normal()
+        @test !f(demo())
+
+        # Ensure we can specialize on number of arguments.
+        @model demo(x) = x ~ Normal()
+        f(::modeltype(demo, 1)) = true
+        @test f(demo(1.0))
+        @test !f(demo()) # should still be `false`
+
+        # Set it to `true` again.
+        f(::modeltype(demo)) = true
+        @test f(demo())
+    end
+end

test/runtests.jl

@@ -47,6 +47,8 @@ include("test_util.jl")
             include("serialization.jl")
 
             include("loglikelihoods.jl")
+
+            include("experimental.jl")
         end
 
         @testset "compat" begin