working on astmodels

src/core/models/abstractmodel.jl

@@ -39,7 +39,7 @@ obstype(::Type{<:AbstractModel}) = NamedTuple{(), Tuple{}}
 
 (m::AbstractModel)(;argvals...)= m((;argvals...))
 
-(m::AbstractModel)(args...) = m(NamedTuple{Tuple(m.args)}(args...))
+(m::AbstractModel{A})(args...) where {A} = m(A(args))
 
 body(::AbstractModel{A,B}) where {A,B} = from_type(B)
 body(::Type{AM}) where {A,B,AM<:AbstractModel{A,B}} = from_type(B)

src/core/utils.jl

@@ -359,6 +359,9 @@ function locally_bound(ex, optic)
     setdiff(globals(isolated), globals(in_context))
 end    
 
+"""
+Given a JuliaVariables "solved" expression, convert back to a standard expression
+"""
 function unsolve(ex)
     ex = unwrap_scoped(ex)
     @match ex begin
@@ -368,6 +371,14 @@ function unsolve(ex)
     end
 end
 
+
+"""
+Return the set of local variable names from a *solved* expression (using JuliaVariables)
+"""
 function locals(ex)
-
+    Tuple(@match ex begin
+        v::JuliaVariables.Var => ifelse(v.is_global, Set{Symbol}(), Set((v.name,)))
+        Expr(head, args...) => union(map(locals, args)...)
+        x => Set{Symbol}()
+    end)
 end

src/primitives/interpret.jl

@@ -2,26 +2,25 @@ export interpret
 
 function interpret(m::ASTModel{A,B,M}, tilde, ctx0) where {A,B,M}
     theModule = getmodule(m)
-    mk_function(theModule, _interpret(m.body, tilde, ctx0))
+    mk_function(theModule, _interpret(theModule, m.body, tilde, ctx0))
 end
 
-# abstract type Maybe{T} end 
-
-
-function _interpret(ast::Expr, _tilde, _args, _obs)
+function _interpret(M, ast::Expr, _tilde, _args, _obs)
     function go(ex)
         @match ex begin
             :($x ~ $d) => begin
+                x = x.name
                 qx = QuoteNode(x)
                 xname = to_type(x)
                 measure = to_type(d)
                 inargs = static(x ∈ getntkeys(_args))
                 inobs = static(x ∈ getntkeys(_obs))
+                varnames = locals(d)
+                varvals = Expr(:tuple, varnames...)
                 quote
-                    # _x_oldval = ifelse($(Expr(:isdefined, $qx)), Just($x), None())
-                    _x_oldval = nothing
-                    _targs = TildeArgs(_ctx, _cfg, _x_oldval, _vars, $inargs, $inobs)
-                    ($x, _ctx, _retn) = $_tilde($xname, $measure, _targs)
+                    ($x, _ctx, _retn) = let targs = Soss.TildeArgs($xname, $measure, NamedTuple{$varnames}($varvals), $inargs, $inobs)
+                        $_tilde($qx, $d, _cfg, _ctx, targs)
+                    end
                 end
             end
 
@@ -31,10 +30,10 @@ function _interpret(ast::Expr, _tilde, _args, _obs)
         end
     end
 
+
     body = go(@q let 
-            $ast
-    end)
-
+            $(solve_scope(ast)).args[2]
+    end) |> unsolve
 
     body
 end
@@ -49,7 +48,7 @@ end
     tilde = T.instance
 
     body = _m.body |> loadvals(_args, _obs)
-    body = _interpret(body, tilde, _args, _obs)
+    body = _interpret(M, body, tilde, _args, _obs)
 
     q = MacroTools.flatten(@q let M
         @inline function(_cfg, _ctx)
@@ -61,4 +60,6 @@ end
             _retn
         end
     end)
+
+    @under_global M q
 end

src/tildeargs.jl

@@ -1,8 +1,10 @@
-struct TildeArgs{Ctx,Cfg,Xold,Vars,inArgs,inObs}
-    context::Ctx             # A value (often a NamedTuple) that typically evolves throughout inference
-    config::Cfg              # A NamedTuple holding configuration parameters, e.g. RNG
-    x_oldval::Xold           # The previous value for the LHS. Because it may not be defined, this must be a `Maybe`
-    vars::Vars  # A named tuple of local variables used in the measure
-    inargs::inArgs              # A StaticBool indicating whether the current LHS is in the arguments
-    inobs::inObs               # A StaticBool indicating whether the current LHS is in the observations
+struct TildeArgs{XName,M,Vars,inArgs,inObs}
+    x_name::XName  # The name of LHS variable, represented at the type level.
+    measure::M     # A type-level representation of the RHS expression 
+    # x_oldval::Xold # The previous value for the LHS. Because it may not be defined, this must be a `Maybe`
+    # ctx::Ctx       # A value (often a NamedTuple) that typically evolves throughout inference
+    # cfg::Cfg       # A NamedTuple holding configuration parameters, e.g. RNG
+    vars::Vars     # A named tuple of local variables used in the measure
+    inargs::inArgs # A StaticBool indicating whether the current LHS is in the arguments
+    inobs::inObs   # A StaticBool indicating whether the current LHS is in the observations
 end