README example fails about soss.jl HOT 32 CLOSED

a = b :: t

a :: t = b

using MeasureTheory, Soss, SampleChainsDynamicHMC

m = @model x begin
    α ~ Lebesgue(ℝ)
    β ~ Normal()
    σ ~ Exponential()
    y ~ For(x) do xj
        Normal(α + β * xj, σ)
    end
    return y
end
x = randn(20)
predα = predictive(m, :α)
y = rand(predα(x=x,α=10.0))

_args = (x=x,)
_data = (y=y,)
_pars = (σ=2,α=3,β=5)

body = quote
    let
        $(sourceLogdensityOf()(m) |> Soss.loadvals(typeof.((_args, _data, _pars))...))
    end
end

eval(body)

julia> body = quote
           let
               $(sourceLogdensityOf()(m) |> Soss.loadvals(typeof.((_args, _data, _pars))...))
           end
       end
quote
    #= REPL[9]:2 =#
    let
        #= REPL[9]:3 =#
        begin
            x::Vector{Float64} = _args.x
            y::Vector{Float64} = _data.y
            σ::Int64 = _pars.σ
            α::Int64 = _pars.α
            β::Int64 = _pars.β
            _ℓ = 0.0
            _ℓ += Soss.logdensityof(Exponential(), σ)
            σ = Soss.predict(Exponential(), σ)
            _ℓ += Soss.logdensityof(Normal(), β)
            β = Soss.predict(Normal(), β)
            _ℓ += Soss.logdensityof(Lebesgue(ℝ), α)
            α = Soss.predict(Lebesgue(ℝ), α)
            _ℓ += Soss.logdensityof(For(x) do xj
                        #= REPL[2]:6 =#
                        Normal(α + β * xj, σ)
                    end, y)
            y = Soss.predict(For(x) do xj
                        #= REPL[2]:6 =#
                        Normal(α + β * xj, σ)
                    end, y)
            nothing
            return _ℓ
        end
    end
end

julia> eval(body)
-272.341

function _logdensityof(::Type{M}, _m::Mdl, _args::A, _data::D, _pars::P) where {M<:TypeLevel, Mdl<:Model, A, D, P}
    body = type2model(Mdl) |> sourceLogdensityOf() |> loadvals(A,D,P)
    @under_global M @q let 
        $body
    end
end

julia> logdensityof(m(x=x) | (y=y,), (σ=2,α=3,β=5))
UnderGlobal(TypeLevel{Module, "Buf{17}()"}, :(let
      begin
          x::Vector{Float64} = _args.x
          y::Vector{Float64} = _data.y
          σ::Int64 = _pars.σ
          α::Int64 = _pars.α
          β::Int64 = _pars.β
          _ℓ = 0.0
          _ℓ += Soss.logdensityof(Exponential(), σ)
          σ = Soss.predict(Exponential(), σ)
          _ℓ += Soss.logdensityof(Normal(), β)
          β = Soss.predict(Normal(), β)
          _ℓ += Soss.logdensityof(Lebesgue(ℝ), α)
          α = Soss.predict(Lebesgue(ℝ), α)
          _ℓ += Soss.logdensityof(For(x) do xj
                      Normal
                      α + β * xj
                      σ
                  end, y)
          y = Soss.predict(For(x) do xj
                      Normal
                      α + β * xj
                      σ
                  end, y)
          nothing
          return _ℓ
      end
  end))

quote
    let M.contents
        M = Core.Box()
        begin
            begin
                #= ...\Git\GeneralizedGenerated.jl\src\closure_conv.jl:56 =#
                let freevars = (M,)
                    #= ...\Git\GeneralizedGenerated.jl\src\closure_conv.jl:57 =#
                    (GeneralizedGenerated.Closure){function = (M, _rng;) -> begin
    begin
        M.contents = (Main).rand(_rng, (Main).Normal())
        (M = M.contents,)
    end
end, Base.typeof(freevars)}(freevars)
                end
            end
        end
    end
end

(f1, f2) =  let M = 1
    function f1(x)
        M = x
    end
    function f2()
        M
    end
    f1, f2
end

julia> f1(2)
2

julia> f2()
2

julia> f1("asda")
"asda"

julia> f2()
"asda"

julia> m = @model begin
           β ~ Normal()
           y ~ For(20) do j
               Normal(μ = β * j)
           end
       end;

julia> post = m(x=x) | (y=y,)
ModelPosterior given
    arguments    (:x,)
    observations (:y,)
@model begin
        β ~ Normal()
        y ~ For(20) do j
                Normal(μ = β * j)
            end
    end

julia> logdensityof(post, (β=2,))
quote
    $(Expr(:meta, :inline))
    β = Core.Box()
    $(Expr(:meta, :((Main).inline)))
    local _retn
    _args = (argvals)(_mc)
    _obs = (observations)(_mc)
    _cfg = (Main).merge(_cfg, (args = _args, obs = _obs, pars = _pars))
    local x
    local β.contents
    local y
    x::Vector{Float64} = _args.x
    y::Vector{Float64} = _obs.y
    β.contents::Int64 = _pars.β
    (β.contents, _ctx, _retn) = (tilde)(logdensityof, (opticcompose)(), static(:β), (Unobserved)(β.contents), (Main).Normal(), _cfg, _ctx)
    (Main).isa(_retn, (Main).Tilde.ReturnNow) && return _retn.value
    (y, _ctx, _retn) = (tilde)(logdensityof, (opticcompose)(), static(:y), (Observed)(y), 
        (Main).For(begin
                let freevars = (β,)
                    (Closure){function = (β, j;) -> begin
                        begin
                            (Main).Normal(μ = (Main).:*(β.contents, j))
                        end
                    end, Base.typeof(freevars)}(freevars)
                end
            end, 20), 
        _cfg, _ctx)
    (Main).isa(_retn, (Main).Tilde.ReturnNow) && return _retn.value
    return (#61)(_ctx, _ctx)
end

 quote
│        let M
│            α = Core.Box()
│            σ = Core.Box()
│            β = Core.Box()
│            begin
│                begin
│                    x::Vector{Float64} = _args.x
│                    y::Vector{Float64} = _data.y
│                    σ.contents::ForwardDiff.Dual{ #= VERY LONG =# } = _pars.σ

julia> x :: Int = 2
ERROR: syntax: type declarations on global variables are not yet supported
Stacktrace:
 [1] top-level scope
   @ REPL[3]:1

julia> let
           x :: Int = 2
       end
2

julia> let x = Core.Box()
           x.contents::Int = 2
       end
ERROR: UndefRefError: access to undefined reference
Stacktrace:
 [1] getproperty(x::Core.Box, f::Symbol)
   @ Base .\Base.jl:42
 [2] top-level scope
   @ REPL[5]:2

@gg function _logdensityof(::Type{M}, _m::Mdl, _args::A, _data::D, _pars::P) where {M<:TypeLevel, Mdl<:Model, A, D, P}
    body = type2model(Mdl) |> sourceLogdensityOf() |> loadvals(A,D,P)
    @under_global M @q let 
        $body
    end
end

@gg function _logdensityof(M::Type{<:TypeLevel}, _m::Model, _args, _data, _pars)
    body = type2model(_m) |> sourceLogdensityOf() |> loadvals(_args, _data, _pars)
    @under_global from_type(_unwrap_type(M)) @q let M
        $body
    end
end

function abmult2(r0::Int)
    r::Int = r0
    if r < 0
        r = -r
    end
    f = x -> x * r
    return f
end