Replace + with accumulate for LogProbAccs

Author: mhauru

src/abstract_varinfo.jl

@@ -358,7 +358,7 @@ Add `logp` to the value of the log of the prior probability in `vi`.
 See also: [`accloglikelihood!!`](@ref), [`acclogp!!`](@ref), [`getlogprior`](@ref), [`setlogprior!!`](@ref).
 """
 function acclogprior!!(vi::AbstractVarInfo, logp)
-    return map_accumulator!!(acc -> acc + LogPriorAccumulator(logp), vi, Val(:LogPrior))
+    return map_accumulator!!(acc -> acclogp(acc, logp), vi, Val(:LogPrior))
 end
 
 """
@@ -369,9 +369,7 @@ Add `logJ` to the value of the log Jacobian in `vi`.
 See also: [`getlogjac`](@ref), [`setlogjac!!`](@ref).
 """
 function acclogjac!!(vi::AbstractVarInfo, logJ)
-    return map_accumulator!!(
-        acc -> acc + LogJacobianAccumulator(logJ), vi, Val(:LogJacobian)
-    )
+    return map_accumulator!!(acc -> acclogp(acc, logJ), vi, Val(:LogJacobian))
 end
 
 """
@@ -382,9 +380,7 @@ Add `logp` to the value of the log of the likelihood in `vi`.
 See also: [`accloglikelihood!!`](@ref), [`acclogp!!`](@ref), [`getloglikelihood`](@ref), [`setloglikelihood!!`](@ref).
 """
 function accloglikelihood!!(vi::AbstractVarInfo, logp)
-    return map_accumulator!!(
-        acc -> acc + LogLikelihoodAccumulator(logp), vi, Val(:LogLikelihood)
-    )
+    return map_accumulator!!(acc -> acclogp(acc, logp), vi, Val(:LogLikelihood))
 end
 
 """

src/default_accumulators.jl

@@ -57,13 +57,7 @@ function combine(acc::LogProbAccumulator, acc2::LogProbAccumulator)
     return basetypeof(acc)(logp(acc) + logp(acc2))
 end
 
-function Base.:+(acc1::LogProbAccumulator, acc2::LogProbAccumulator)
-    if basetypeof(acc1) !== basetypeof(acc2)
-        msg = "Cannot add accumulators of different types: $(basetypeof(acc1)) and $(basetypeof(acc2))"
-        throw(ArgumentError(msg))
-    end
-    return basetypeof(acc1)(logp(acc1) + logp(acc2))
-end
+acclogp(acc::LogProbAccumulator, val) = basetypeof(acc)(logp(acc) + val)
 
 Base.zero(acc::T) where {T<:LogProbAccumulator} = T(zero(logp(acc)))
 
@@ -99,7 +93,7 @@ logp(acc::LogPriorAccumulator) = acc.logp
 accumulator_name(::Type{<:LogPriorAccumulator}) = :LogPrior
 
 function accumulate_assume!!(acc::LogPriorAccumulator, val, logjac, vn, right)
-    return acc + LogPriorAccumulator(logpdf(right, val))
+    return acclogp(acc, logpdf(right, val))
 end
 accumulate_observe!!(acc::LogPriorAccumulator, right, left, vn) = acc
 
@@ -143,7 +137,7 @@ logp(acc::LogJacobianAccumulator) = acc.logJ
 accumulator_name(::Type{<:LogJacobianAccumulator}) = :LogJacobian
 
 function accumulate_assume!!(acc::LogJacobianAccumulator, val, logjac, vn, right)
-    return acc + LogJacobianAccumulator(logjac)
+    return acclogp(acc, logjac)
 end
 accumulate_observe!!(acc::LogJacobianAccumulator, right, left, vn) = acc
 
@@ -169,7 +163,7 @@ function accumulate_observe!!(acc::LogLikelihoodAccumulator, right, left, vn)
     # Note that it's important to use the loglikelihood function here, not logpdf, because
     # they handle vectors differently:
     # https://github.com/JuliaStats/Distributions.jl/issues/1972
-    return acc + LogLikelihoodAccumulator(Distributions.loglikelihood(right, left))
+    return acclogp(acc, Distributions.loglikelihood(right, left))
 end
 
 """
@@ -208,7 +202,7 @@ end
 
 function Base.show(io::IO, acc::VariableOrderAccumulator)
     return print(
-        io, "VariableOrderAccumulator($(repr(acc.num_produce)), $(repr(acc.order)))"
+        io, "VariableOrderAccumulator($(string(acc.num_produce)), $(repr(acc.order)))"
     )
 end
 

test/accumulators.jl

@@ -39,13 +39,11 @@ using DynamicPPL:
         end
 
         @testset "addition and incrementation" begin
-            @test LogPriorAccumulator(1.0f0) + LogPriorAccumulator(1.0f0) ==
-                LogPriorAccumulator(2.0f0)
-            @test LogPriorAccumulator(1.0) + LogPriorAccumulator(1.0f0) ==
-                LogPriorAccumulator(2.0)
-            @test LogLikelihoodAccumulator(1.0f0) + LogLikelihoodAccumulator(1.0f0) ==
+            @test acclogp(LogPriorAccumulator(1.0f0), 1.0f0) == LogPriorAccumulator(2.0f0)
+            @test acclogp(LogPriorAccumulator(1.0), 1.0f0) == LogPriorAccumulator(2.0)
+            @test acclogp(LogLikelihoodAccumulator(1.0f0), 1.0f0) ==
                 LogLikelihoodAccumulator(2.0f0)
-            @test LogLikelihoodAccumulator(1.0) + LogLikelihoodAccumulator(1.0f0) ==
+            @test acclogp(LogLikelihoodAccumulator(1.0), 1.0f0) ==
                 LogLikelihoodAccumulator(2.0)
             @test increment(VariableOrderAccumulator()) == VariableOrderAccumulator(1)
             @test increment(VariableOrderAccumulator{UInt8}()) ==