formatting

Author: cscherrer

.JuliaFormatter.toml

@@ -6,7 +6,7 @@ whitespace_ops_in_indices = false
 remove_extra_newlines = true
 import_to_using = false
 pipe_to_function_call = false
-short_to_long_function_def = false
+short_to_long_function_def = true
 always_use_return = false
 whitespace_in_kwargs = true
 annotate_untyped_fields_with_any = false

src/MeasureBase.jl

@@ -131,4 +131,4 @@ include("interface.jl")
 
 using .Interface
 
-end # module MeasureBase
+end # module MeasureBase

src/combinators/bind.jl

@@ -33,4 +33,4 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::Bind) where {T}
     x = rand(rng, T, d.μ)
     y = rand(rng, T, d.k(x))
     return y
-end
+end

src/combinators/conditional.jl

@@ -1,5 +1,5 @@
 struct ConditionalMeasure{M,C} <: AbstractMeasure
-    parent::M 
+    parent::M
     constraint::C
 end
 
@@ -37,10 +37,13 @@ condition(μ, constraint) = ConditionalMeasure(μ, constraint)
 #     end
 # end
 
-function Base.:|(μ::ProductMeasure{NamedTuple{M,T}}, constraint::NamedTuple{N}) where {M,T,N}
-    productmeasure(merge(marginals(μ),rmap(Dirac, constraint)))
+function Base.:|(
+    μ::ProductMeasure{NamedTuple{M,T}},
+    constraint::NamedTuple{N},
+) where {M,T,N}
+    productmeasure(merge(marginals(μ), rmap(Dirac, constraint)))
 end
 
 function Pretty.tile(d::ConditionalMeasure)
-    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.constraint), sep=" | ")
-end
+    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.constraint), sep = " | ")
+end

src/combinators/for.jl

@@ -0,0 +1 @@
+

src/combinators/likelihood.jl

@@ -116,8 +116,8 @@ struct Likelihood{K,X} <: AbstractLikelihood
     k::K
     x::X
 
-    Likelihood(k::K, x::X) where {K<:AbstractTransitionKernel,X} = new{K,X}(k,x)
-    Likelihood(k::K, x::X) where {K<:Function,X} = new{K,X}(k,x)
+    Likelihood(k::K, x::X) where {K<:AbstractTransitionKernel,X} = new{K,X}(k, x)
+    Likelihood(k::K, x::X) where {K<:Function,X} = new{K,X}(k, x)
     Likelihood(μ, x) = Likelihood(kernel(μ), x)
 end
 

src/combinators/pointwise.jl

@@ -5,12 +5,10 @@ struct PointwiseProductMeasure{P,L} <: AbstractMeasure
     likelihood::L
 end
 
-
-
-iterate(p::PointwiseProductMeasure, i=1) = iterate((p.prior, p.likelihood), i)
+iterate(p::PointwiseProductMeasure, i = 1) = iterate((p.prior, p.likelihood), i)
 
 function Pretty.tile(d::PointwiseProductMeasure)
-    Pretty.pair_layout(Pretty.tile(d.prior), Pretty.tile(d.likelihood), sep=" ⊙ ")
+    Pretty.pair_layout(Pretty.tile(d.prior), Pretty.tile(d.likelihood), sep = " ⊙ ")
 end
 
 ⊙(μ, ℓ) = pointwiseproduct(μ, ℓ)
@@ -24,7 +22,7 @@ function gentype(d::PointwiseProductMeasure)
     gentype(d.prior)
 end
 
-@inbounds function insupport(d::PointwiseProductMeasure, p) 
+@inbounds function insupport(d::PointwiseProductMeasure, p)
     μ, ℓ = d
     insupport(μ, p) && insupport(ℓ.k(p), ℓ.x)
 end

src/combinators/power.jl

@@ -24,7 +24,11 @@ function Pretty.tile(μ::PowerMeasure)
     return Pretty.pair_layout(arg1, arg2; sep = " ^ ")
 end
 
-function Base.rand(rng::AbstractRNG, ::Type{T}, d::PowerMeasure{M}) where {T, M<:AbstractMeasure}
+function Base.rand(
+    rng::AbstractRNG,
+    ::Type{T},
+    d::PowerMeasure{M},
+) where {T,M<:AbstractMeasure}
     map(CartesianIndices(d.axes)) do _
         rand(rng, T, d.parent)
     end
@@ -36,10 +40,10 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::PowerMeasure) where {T}
     end
 end
 
-@inline function powermeasure(x::T, sz::Tuple{Vararg{<:Any,N}}) where {T, N}
-    a = axes(Fill{T, N}(x, sz))
+@inline function powermeasure(x::T, sz::Tuple{Vararg{<:Any,N}}) where {T,N}
+    a = axes(Fill{T,N}(x, sz))
     A = typeof(a)
-    PowerMeasure{T,A}(x,a)
+    PowerMeasure{T,A}(x, a)
 end
 
 marginals(d::PowerMeasure) = Fill(d.parent, d.axes)
@@ -61,7 +65,7 @@ params(d::PowerMeasure) = params(first(marginals(d)))
 # basemeasure(μ::PowerMeasure) = @inbounds basemeasure(first(μ.data))^size(μ.data)
 
 @inline function basemeasure(d::PowerMeasure)
-    basemeasure(d.parent) ^ d.axes
+    basemeasure(d.parent)^d.axes
 end
 
 @inline function logdensity_def(d::PowerMeasure{M}, x) where {M}
@@ -71,7 +75,10 @@ end
     end
 end
 
-@inline function logdensity_def(d::PowerMeasure{M, Tuple{Base.OneTo{StaticInt{N}}}}, x) where {M,N}
+@inline function logdensity_def(
+    d::PowerMeasure{M,Tuple{Base.OneTo{StaticInt{N}}}},
+    x,
+) where {M,N}
     parent = d.parent
     sum(1:N) do j
         @inbounds logdensity_def(parent, x[j])
@@ -92,4 +99,4 @@ end
         # https://github.com/SciML/Static.jl/issues/36
         dynamic(insupport(p, xj))
     end
-end
+end

src/combinators/powerweighted.jl

@@ -7,16 +7,16 @@ end
 
 logdensity_def(d::PowerWeightedMeasure, x) = d.exponent * logdensity_def(d.parent, x)
 
-basemeasure(d::PowerWeightedMeasure, x) = basemeasure(d.parent, x) ↑ d.exponent
+basemeasure(d::PowerWeightedMeasure, x) = basemeasure(d.parent, x)↑d.exponent
 
-basemeasure(d::PowerWeightedMeasure) = basemeasure(d.parent) ↑ d.exponent
+basemeasure(d::PowerWeightedMeasure) = basemeasure(d.parent)↑d.exponent
 
 function powerweightedmeasure(d, α)
     isone(α) && return d
     PowerWeightedMeasure(d, α)
 end
 
-(d::AbstractMeasure) ↑ α = powerweightedmeasure(d, α)
+(d::AbstractMeasure)↑α = powerweightedmeasure(d, α)
 
 insupport(d::PowerWeightedMeasure, x) = insupport(d.parent, x)
 
@@ -29,9 +29,9 @@ function powerweightedmeasure(d::PowerWeightedMeasure, α)
 end
 
 function powerweightedmeasure(d::WeightedMeasure, α)
-    weightedmeasure(α*d.logweight, powerweightedmeasure(d.base, α))
+    weightedmeasure(α * d.logweight, powerweightedmeasure(d.base, α))
 end
 
 function Pretty.tile(d::PowerWeightedMeasure)
-    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.exponent), sep=" ↑ ")
-end
+    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.exponent), sep = " ↑ ")
+end

src/combinators/product.jl

@@ -31,13 +31,23 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::AbstractProductMeasure) where
     _rand_product(rng, T, mar, eltype(mar))
 end
 
-function _rand_product(rng::AbstractRNG, ::Type{T}, mar, ::Type{M}) where {T,M<:AbstractMeasure}
+function _rand_product(
+    rng::AbstractRNG,
+    ::Type{T},
+    mar,
+    ::Type{M},
+) where {T,M<:AbstractMeasure}
     map(mar) do dⱼ
         rand(rng, T, dⱼ)
     end
 end
 
-function _rand_product(rng::AbstractRNG, ::Type{T}, mar::ReadonlyMappedArray, ::Type{M}) where {T,M<:AbstractMeasure}
+function _rand_product(
+    rng::AbstractRNG,
+    ::Type{T},
+    mar::ReadonlyMappedArray,
+    ::Type{M},
+) where {T,M<:AbstractMeasure}
     mappedarray(mar.data) do dⱼ
         rand(rng, T, mar.f(dⱼ))
     end |> collect
@@ -49,14 +59,17 @@ function _rand_product(rng::AbstractRNG, ::Type{T}, mar, ::Type{M}) where {T,M}
     end
 end
 
-
-function _rand_product(rng::AbstractRNG, ::Type{T}, mar::ReadonlyMappedArray, ::Type{M}) where {T,M}
+function _rand_product(
+    rng::AbstractRNG,
+    ::Type{T},
+    mar::ReadonlyMappedArray,
+    ::Type{M},
+) where {T,M}
     mappedarray(mar.data) do dⱼ
         rand(rng, mar.f(dⱼ))
     end |> collect
 end
 
-
 @inline function logdensity_def(d::AbstractProductMeasure, x)
     mapreduce(logdensity_def, +, marginals(d), x)
 end
@@ -70,12 +83,12 @@ end
 end
 
 function Pretty.tile(d::ProductMeasure{T}) where {T<:Tuple}
-    Pretty.list_layout(Pretty.tile.([marginals(d)...]), sep=" ⊗ ")
+    Pretty.list_layout(Pretty.tile.([marginals(d)...]), sep = " ⊗ ")
 end
 
 # For tuples, `mapreduce` has trouble with type inference
 @inline function logdensity_def(d::ProductMeasure{T}, x) where {T<:Tuple}
-    ℓs = map(logdensity_def, marginals(d),x)
+    ℓs = map(logdensity_def, marginals(d), x)
     sum(ℓs)
 end
 
@@ -115,30 +128,35 @@ function basemeasure(μ::ProductMeasure{Base.Generator{I,F}}) where {I,F}
     _basemeasure(μ, B, static(Base.issingletontype(B)))
 end
 
-
-
 function basemeasure(μ::ProductMeasure{A}) where {T,A<:AbstractMappedArray{T}}
     B = Core.Compiler.return_type(basemeasure, Tuple{T})
     _basemeasure(μ, B, static(Base.issingletontype(B)))
 end
 
 function _basemeasure(μ::ProductMeasure, ::Type{B}, ::True) where {T,B}
-    return instance(B) ^ axes(marginals(μ))
+    return instance(B)^axes(marginals(μ))
 end
 
-function _basemeasure(μ::ProductMeasure{A}, ::Type{B}, ::False) where {T,A<:AbstractMappedArray{T},B}
+function _basemeasure(
+    μ::ProductMeasure{A},
+    ::Type{B},
+    ::False,
+) where {T,A<:AbstractMappedArray{T},B}
     mar = marginals(μ)
     productmeasure(mappedarray(basemeasure, mar))
 end
 
-function _basemeasure(μ::ProductMeasure{Base.Generator{I,F}}, ::Type{B}, ::False) where {I,F,B}
+function _basemeasure(
+    μ::ProductMeasure{Base.Generator{I,F}},
+    ::Type{B},
+    ::False,
+) where {I,F,B}
     mar = marginals(μ)
     productmeasure(Base.Generator(basekernel(mar.f), mar.iter))
 end
 
 marginals(μ::ProductMeasure) = μ.marginals
 
-
 testvalue(d::AbstractProductMeasure) = map(testvalue, marginals(d))
 
 export ⊗
@@ -184,18 +202,17 @@ function _rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure, mar::AbstractArra
     rand!(rng, d, x)
 end
 
-
 @inline function insupport(d::AbstractProductMeasure, x::AbstractArray)
     mar = marginals(d)
-    for (j,mj) in enumerate(mar)
+    for (j, mj) in enumerate(mar)
         dynamic(insupport(mj, x[j])) || return false
     end
     return true
 end
 
 @inline function insupport(d::AbstractProductMeasure, x)
-    for (mj,xj) in zip(marginals(d), x)
+    for (mj, xj) in zip(marginals(d), x)
         dynamic(insupport(mj, xj)) || return false
     end
     return true
-end
+end

src/combinators/restricted.jl

@@ -13,4 +13,4 @@ function Pretty.quoteof(d::RestrictedMeasure)
     qf = Pretty.quoteof(d.predicate)
     qbase = Pretty.quoteof(d.base)
     :(RestrictedMeasure($qf, $qbase))
-end
+end

src/combinators/smart-constructors.jl

@@ -53,8 +53,9 @@ productmeasure(tup::Tuple) = ProductMeasure(tup)
 
 productmeasure(f, param_maps, pars) = ProductMeasure(kernel(f, param_maps), pars)
 
-productmeasure(k::ParameterizedTransitionKernel, pars) = productmeasure(k.f, k.param_maps, pars)
-
+function productmeasure(k::ParameterizedTransitionKernel, pars)
+    productmeasure(k.f, k.param_maps, pars)
+end
 
 function productmeasure(f::Returns{W}, ::typeof(identity), pars) where {W<:WeightedMeasure}
     ℓ = _logweight(f.value)
@@ -140,4 +141,3 @@ function kernel(::Type{M}; param_maps...) where {M}
 end
 
 kernel(k::ParameterizedTransitionKernel) = k
-

src/combinators/spikemixture.jl

@@ -8,10 +8,10 @@ struct SpikeMixture{M,W,S} <: AbstractMeasure
     s::S   # spike weight
 end
 
-SpikeMixture(μ,w) = SpikeMixture(μ, w, static(1.0) - w) 
+SpikeMixture(μ, w) = SpikeMixture(μ, w, static(1.0) - w)
 
 function Pretty.tile(μ::SpikeMixture)
-    Pretty.list_layout(Pretty.tile.([μ.m, μ.w]), prefix="SpikeMixture")
+    Pretty.list_layout(Pretty.tile.([μ.m, μ.w]), prefix = "SpikeMixture")
 end
 
 # TODO: Should this base measure be local? 
@@ -21,10 +21,9 @@ end
     SpikeMixture(basemeasure(μ.m), static(1.0), static(1.0))
 end
 
-
 @inline function logdensity_def(μ::SpikeMixture, x)
     if iszero(x)
-        return log(μ.s) 
+        return log(μ.s)
     else
         return log(μ.w) + logdensity_def(μ.m, x)
     end
@@ -40,4 +39,4 @@ end
 
 testvalue(μ::SpikeMixture) = testvalue(μ.m)
 
-insupport(μ::SpikeMixture, x) = dynamic(insupport(μ.m, x)) || iszero(x) 
+insupport(μ::SpikeMixture, x) = dynamic(insupport(μ.m, x)) || iszero(x)

src/combinators/transformedmeasure.jl

@@ -12,4 +12,4 @@ function params(::AbstractTransformedMeasure) end
 
 function paramnames(::AbstractTransformedMeasure) end
 
-function parent(::AbstractTransformedMeasure) end
+function parent(::AbstractTransformedMeasure) end

src/combinators/weighted.jl

@@ -31,8 +31,8 @@ _logweight(μ::WeightedMeasure) = μ.logweight
 basemeasure(μ::AbstractWeightedMeasure) = μ.base
 
 function Pretty.tile(d::WeightedMeasure)
-    weight = round(exp(d.logweight), sigdigits=4)
-    Pretty.pair_layout(Pretty.tile(weight), Pretty.tile(d.base), sep=" * ")
+    weight = round(exp(d.logweight), sigdigits = 4)
+    Pretty.pair_layout(Pretty.tile(weight), Pretty.tile(d.base), sep = " * ")
 end
 
 function Base.:*(k::T, m::AbstractMeasure) where {T<:Number}
@@ -47,4 +47,4 @@ Base.:*(m::AbstractMeasure, k::Real) = k * m
 
 gentype(μ::WeightedMeasure) = gentype(μ.base)
 
-insupport(μ::WeightedMeasure, x) = insupport(μ.base, x)
+insupport(μ::WeightedMeasure, x) = insupport(μ.base, x)

src/density.jl

@@ -78,7 +78,6 @@ logdensity_def(μ::DensityMeasure, x) = logdensityof(μ.f, x)
 
 density_def(μ::DensityMeasure, x) = densityof(μ.f, x)
 
-
 export ∫
 
 """
@@ -142,12 +141,12 @@ See also `logdensityof`.
     ℓ_0 = logdensity_def(μ, x)
     b_0 = μ
     Base.Cartesian.@nexprs 10 i -> begin  # 10 is just some "big enough" number
-        b_{i} = basemeasure(b_{i-1}, x)
-        if b_{i} isa typeof(b_{i-1})
-            return ℓ_{i-1}
+        b_{i} = basemeasure(b_{i - 1}, x)
+        if b_{i} isa typeof(b_{i - 1})
+            return ℓ_{i - 1}
         end
         ℓ_{i} = let Δℓ_{i} = logdensity_def(b_{i}, x)
-            ℓ_{i-1} + Δℓ_{i}
+            ℓ_{i - 1} + Δℓ_{i}
         end
     end
     return ℓ_10
@@ -162,7 +161,7 @@ export logdensity_rel
 @inline return_type(f, args::Tuple) = Core.Compiler.return_type(f, Tuple{typeof.(args)...})
 
 unstatic(::Type{T}) where {T} = T
-unstatic(::Type{StaticFloat64{X}}) where X = Float64
+unstatic(::Type{StaticFloat64{X}}) where {X} = Float64
 
 """
     logdensity_rel(m1, m2, x)
@@ -173,7 +172,12 @@ known to be in the support of both, it can be more efficient to call
 `unsafe_logdensity_rel`. 
 """
 @inline function logdensity_rel(μ::M, ν::N, x::X) where {M,N,X}
-    T = unstatic(promote_type(return_type(logdensity_def, (μ, x)), return_type(logdensity_def, (ν, x))))
+    T = unstatic(
+        promote_type(
+            return_type(logdensity_def, (μ, x)),
+            return_type(logdensity_def, (ν, x)),
+        ),
+    )
     inμ = insupport(μ, x)
     inν = insupport(ν, x)
     inμ || return convert(T, ifelse(inν, -Inf, NaN))
@@ -191,7 +195,7 @@ known to be in the support of both `m1` and `m2`.
 See also `logdensity_rel`.
 """
 @inline function unsafe_logdensity_rel(μ::M, ν::N, x::X) where {M,N,X}
-    if static_hasmethod(logdensity_def, Tuple{M, N, X})
+    if static_hasmethod(logdensity_def, Tuple{M,N,X})
         return logdensity_def(μ, ν, x)
     end
     μs = basemeasure_sequence(μ)
@@ -221,19 +225,24 @@ function logdensity_def(μ::T, ν::T, x) where {T}
     if μ === ν
         return zero(logdensity_def(μ, x))
     else
-        return logdensity_def(μ,x) - logdensity_def(ν, x)
+        return logdensity_def(μ, x) - logdensity_def(ν, x)
     end
 end
 
-@generated function _logdensity_rel(μs::Tμ, νs::Tν, ::Tuple{StaticInt{M},StaticInt{N}}, x::X)  where {Tμ, Tν,M,N,X}
+@generated function _logdensity_rel(
+    μs::Tμ,
+    νs::Tν,
+    ::Tuple{StaticInt{M},StaticInt{N}},
+    x::X,
+) where {Tμ,Tν,M,N,X}
     sμ = schema(Tμ)
     sν = schema(Tν)
-   
-    q = quote 
+
+    q = quote
         $(Expr(:meta, :inline))
         ℓ = logdensity_def(μs[$M], νs[$N], x)
     end
-    
+
     for i in 1:M-1
         push!(q.args, :(Δℓ = logdensity_def(μs[$i], x)))
         # push!(q.args, :(println("Adding", Δℓ)))
@@ -267,4 +276,4 @@ basemeasure(rebase(μ, ν)) == ν
 density(rebase(μ, ν)) == 𝒹(μ,ν)
 ``` 
 """
-rebase(μ, ν) = ∫(𝒹(μ,ν), ν)
+rebase(μ, ν) = ∫(𝒹(μ, ν), ν)

src/domains.jl

@@ -74,30 +74,34 @@ end
 
 export ZeroSet
 
-struct ZeroSet{F, G} <: AbstractDomain
+struct ZeroSet{F,G} <: AbstractDomain
     f::F
     ∇f::G
 end
 
 # Based on some quick tests, but may need some adjustment
 Base.in(x::AbstractArray{T}, z::ZeroSet) where {T} = abs(z.f(x)) < ldexp(eps(float(T)), 6)
 
-
 ###########################################################
 # CodimOne
 
 export CodimOne
 
 abstract type CodimOne <: AbstractDomain end
 
-function tangentat(a::CodimOne, b::CodimOne, x::AbstractArray{T}; tol=ldexp(eps(float(T)), 6)) where {T}
+function tangentat(
+    a::CodimOne,
+    b::CodimOne,
+    x::AbstractArray{T};
+    tol = ldexp(eps(float(T)), 6),
+) where {T}
     # Sometimes you get lucky
     a == b && return true
 
     # Get the normal vectors
     g1 = a.∇f(x)
     g2 = b.∇f(x)
-    
+
     # See if one is a multiple of the other
     one(T) - Statistics.corm(g1, zero(T), g2, zero(T)) < tol
 end
@@ -110,13 +114,13 @@ export Simplex
 
 struct Simplex <: CodimOne end
 
-function zeroset(::Simplex) 
+function zeroset(::Simplex)
     f(x::AbstractArray{T}) where {T} = sum(x) - one(T)
     ∇f(x::AbstractArray{T}) where {T} = Fill(one(T), size(x))
     ZeroSet(f, ∇f)
 end
 
-function Base.in(x::AbstractArray{T}, ::Simplex) where {T} 
+function Base.in(x::AbstractArray{T}, ::Simplex) where {T}
     all(≥(zero(eltype(x))), x) || return false
     return x ∈ zeroset(Simplex())
 end
@@ -128,15 +132,14 @@ projectto!(x, ::Simplex) = normalize!(x, 1)
 
 struct Sphere <: CodimOne end
 
-function zeroset(::Sphere) 
+function zeroset(::Sphere)
     f(x::AbstractArray{T}) where {T} = sum(xⱼ -> xⱼ^2, x) - one(T)
     ∇f(x::AbstractArray{T}) where {T} = x
     ZeroSet(f, ∇f)
 end
 
-function Base.in(x::AbstractArray{T}, ::Sphere) where {T} 
+function Base.in(x::AbstractArray{T}, ::Sphere) where {T}
     return x ∈ zeroset(Sphere())
 end
 
 projectto!(x, ::Sphere) = normalize!(x, 2)
-

src/interface.jl

@@ -4,7 +4,7 @@ using Reexport
 
 @reexport using MeasureBase
 
-using MeasureBase:basemeasure_depth, proxy
+using MeasureBase: basemeasure_depth, proxy
 using MeasureBase: insupport, basemeasure_sequence, commonbase
 
 export test_interface
@@ -31,10 +31,10 @@ function test_interface(μ::M) where {M}
         μ = $μ
         @testset "$μ" begin
             μ = $μ
-           
+
             ###########################################################################
             # basemeasure_depth
-            static_depth = @inferred basemeasure_depth(μ) 
+            static_depth = @inferred basemeasure_depth(μ)
 
             dynamic_depth = dynamic_basemeasure_depth(μ)
 
@@ -58,6 +58,3 @@ function test_interface(μ::M) where {M}
 end
 
 end # module Interface
-
-
-

src/kernel.jl

@@ -5,10 +5,15 @@ struct ParameterizedTransitionKernel{F,N,T} <: AbstractTransitionKernel
     f::F
     param_maps::NamedTuple{N,T}
 
-    ParameterizedTransitionKernel(::Type{F}, param_maps::NamedTuple{N,T}) where {F,N,T} =
+    function ParameterizedTransitionKernel(
+        ::Type{F},
+        param_maps::NamedTuple{N,T},
+    ) where {F,N,T}
         new{Type{F},N,T}(F, param_maps)
-    ParameterizedTransitionKernel(f::F, param_maps::NamedTuple{N,T}) where {F,N,T} =
+    end
+    function ParameterizedTransitionKernel(f::F, param_maps::NamedTuple{N,T}) where {F,N,T}
         new{F,N,T}(f, param_maps)
+    end
 end
 
 """
@@ -32,7 +37,6 @@ another common use of this term.
 """
 function kernel end
 
-
 # kernel(Normal) do x
 #     (μ=x,σ=x^2)
 # end
@@ -51,7 +55,6 @@ function (k::ParameterizedTransitionKernel)(x::Tuple)
     k.f(NamedTuple{k.param_maps}(x))
 end
 
-
 """
 For any `k::TransitionKernel`, `basekernel` is expected to satisfy
 ```
@@ -72,7 +75,6 @@ basekernel(k::ParameterizedTransitionKernel) = kernel(basekernel(k.f), k.param_m
 
 basekernel(f::Returns) = Returns(basemeasure(f.value))
 
-
 function Base.show(io::IO, μ::AbstractTransitionKernel)
     io = IOContext(io, :compact => true)
     Pretty.pprint(io, μ)
@@ -86,4 +88,4 @@ end
 
 const kleisli = kernel
 
-export kleisli
+export kleisli

src/parameterized.jl

@@ -28,7 +28,7 @@ end
 #
 
 function kernel(::Type{P}) where {N,P<:ParameterizedMeasure{N}}
-    C = constructorof(P) 
+    C = constructorof(P)
     _kernel(C, Val(N))
 end
 
@@ -37,7 +37,7 @@ end
         C(NamedTuple{N,T}(args))::C{N,T}
     end
 
-    @inline function f(arg::T) where {T} 
+    @inline function f(arg::T) where {T}
         C(NamedTuple{N,Tuple{T}}((arg,)))::C{N,Tuple{T}}
     end
 
@@ -113,8 +113,6 @@ See also `params`
 """
 function paramnames end
 
-
-
 paramnames(μ::M) where {M} = paramnames(M)
 
 paramnames(::Type{PM}) where {N,PM<:ParameterizedMeasure{N}} = N

src/primitives/counting.jl

@@ -30,4 +30,4 @@ Base.show(io::IO, d::Counting) = print(io, "Counting(", d.support, ")")
 
 insupport(μ::Counting, x) = x ∈ μ.support
 
-insupport(μ::Counting{T}, x) where {T<:Type} = x isa μ.support
+insupport(μ::Counting{T}, x) where {T<:Type} = x isa μ.support

src/primitives/lebesgue.jl

@@ -15,7 +15,7 @@ struct Lebesgue{T} <: AbstractMeasure
 end
 
 function Pretty.tile(μ::Lebesgue)
-    Pretty.list_layout([Pretty.tile(μ.support)]; prefix=:Lebesgue)
+    Pretty.list_layout([Pretty.tile(μ.support)]; prefix = :Lebesgue)
 end
 
 gentype(::Lebesgue) = Float64
@@ -39,4 +39,4 @@ insupport(::Lebesgue{RealNumbers}, ::Real) = true
 
 logdensity_def(::LebesgueMeasure, ::CountingMeasure, x) = -Inf
 
-logdensity_def(::CountingMeasure, ::LebesgueMeasure, x) = Inf
+logdensity_def(::CountingMeasure, ::LebesgueMeasure, x) = Inf

src/schema.jl

@@ -1,7 +1,7 @@
 # Taken from https://github.com/cscherrer/NestedTuples.jl/blob/cd298fd1e5f7e571701a6fee916d2d47c19f32f5/src/typelevel.jl
 
-ntkeys(::Type{NamedTuple{K,V}}) where {K, V} = K
-ntvaltype(::Type{NamedTuple{K,V}}) where {K, V} = V
+ntkeys(::Type{NamedTuple{K,V}}) where {K,V} = K
+ntvaltype(::Type{NamedTuple{K,V}}) where {K,V} = V
 
 """
     schema(::Type)
@@ -16,19 +16,19 @@ Example:
 """
 function schema end
 
-schema(::NamedTuple{(), Tuple{}}) = NamedTuple()
-schema(::Type{NamedTuple{(), Tuple{}}}) = NamedTuple()
+schema(::NamedTuple{(),Tuple{}}) = NamedTuple()
+schema(::Type{NamedTuple{(),Tuple{}}}) = NamedTuple()
 
-function schema(NT::Type{NamedTuple{names, T}}) where {names, T}
+function schema(NT::Type{NamedTuple{names,T}}) where {names,T}
     return NamedTuple{ntkeys(NT)}(schema(ntvaltype(NT)))
 end
 
-function schema(TT::Type{T}) where {T <: Tuple} 
+function schema(TT::Type{T}) where {T<:Tuple}
     return schema.(Tuple(TT.types))
 end
 
-schema(t::T) where {T <: Tuple} = schema(T) 
+schema(t::T) where {T<:Tuple} = schema(T)
 
-schema(t::T) where {T <: NamedTuple} = schema(T) 
+schema(t::T) where {T<:NamedTuple} = schema(T)
 
-schema(T) = T
+schema(T) = T

src/splat.jl

@@ -2,7 +2,7 @@ struct Splat{F}
     f::F
 end
 
-function (s::Splat{F})(x) where F
+function (s::Splat{F})(x) where {F}
     s.f(x...)
 end
 

src/utils.jl

@@ -8,7 +8,6 @@ end
 showparams(io::IO, ::EmptyNamedTuple) = print(io, "()")
 showparams(io::IO, nt::NamedTuple) = print(io, nt)
 
-
 export testvalue
 testvalue(μ::AbstractMeasure) = testvalue(basemeasure(μ))
 testvalue(::Type{T}) where {T} = zero(T)
@@ -47,7 +46,6 @@ end
 
 # issingletontype(@nospecialize(t)) = (@_pure_meta; isa(t, DataType) && isdefined(t, :instance))
 
-
 # @generated function instance(::Type{T}) where {T}
 #     return getfield(T, :instance)::T
 # end
@@ -61,9 +59,9 @@ export basemeasure_depth
 @inline function basemeasure_depth(μ::M) where {M}
     b_0 = μ
     Base.Cartesian.@nexprs 10 i -> begin  # 10 is just some "big enough" number
-        b_{i} = basemeasure(b_{i-1})
-        if b_{i} isa typeof(b_{i-1})
-            return static(i-1)
+        b_{i} = basemeasure(b_{i - 1})
+        if b_{i} isa typeof(b_{i - 1})
+            return static(i - 1)
         end
     end
     return static(10)
@@ -79,16 +77,20 @@ measure of the previous term, and with no repeated entries.
     b_1 = μ
     done = false
     Base.Cartesian.@nexprs 10 i -> begin  # 10 is just some "big enough" number
-        b_{i+1} = if done nothing else basemeasure(b_{i}) end
-        if b_{i+1} isa typeof(b_{i})
+        b_{i + 1} = if done
+            nothing
+        else
+            basemeasure(b_{i})
+        end
+        if b_{i + 1} isa typeof(b_{i})
             done = true
-            b_{i+1} = nothing
+            b_{i + 1} = nothing
         end
     end
     return filter(!isnothing, Base.Cartesian.@ntuple 10 b)
 end
 
-commonbase(μ, ν) = commonbase(μ, ν, Any) 
+commonbase(μ, ν) = commonbase(μ, ν, Any)
 
 """
     commonbase(μ, ν, T) -> Tuple{StaticInt{i}, StaticInt{j}}
@@ -107,9 +109,12 @@ end
     m = schema(M)
     n = schema(N)
 
-    sols = Iterators.filter(((i,j),) ->  static_hasmethod(logdensity_def, Tuple{m[i], n[j], T}), Iterators.product(1:length(m), 1:length(n))) 
+    sols = Iterators.filter(
+        ((i, j),) -> static_hasmethod(logdensity_def, Tuple{m[i],n[j],T}),
+        Iterators.product(1:length(m), 1:length(n)),
+    )
     isempty(sols) && return :(nothing)
-    minsol = static.(argmin(((i,j),) -> i+j, sols))
+    minsol = static.(argmin(((i, j),) -> i + j, sols))
     quote
         $minsol
     end
@@ -131,15 +136,14 @@ end
     return true
 end
 
-
 allequal(x::AbstractArray) = allequal(identity, x)
 
 rmap(f, x) = f(x)
 
 function rmap(f, t::Tuple)
-    map(x -> rmap(f,x), t)
+    map(x -> rmap(f, x), t)
 end
 
 function rmap(f, nt::NamedTuple{N,T}) where {N,T}
-    NamedTuple{N}(map(x -> rmap(f,x), values(nt)))
-end
+    NamedTuple{N}(map(x -> rmap(f, x), values(nt)))
+end

test/combinators/superpose.jl

@@ -15,7 +15,8 @@ using MeasureBase: superpose
     μs = SuperpositionMeasure([μ, ν])
     @test μs isa SuperpositionMeasure{<:AbstractVector{<:AbstractMeasure}}
     @test_throws ErrorException density_def(μs, 0)
-    @test basemeasure(μs).components == SuperpositionMeasure([CountingMeasure(), CountingMeasure()]).components
+    @test basemeasure(μs).components ==
+          SuperpositionMeasure([CountingMeasure(), CountingMeasure()]).components
 
     μ2 = μ + μ
     @test μ2 isa WeightedMeasure

test/combinators/weighted.jl

@@ -13,7 +13,7 @@ using MeasureBase: _logweight, weightedmeasure, WeightedMeasure
     @test μ isa WeightedMeasure
     @test _logweight(μ) == log(w)
     @test _logweight(w * μ) == 2 * log(w)
-    @test rand(MersenneTwister(123), μ) == rand(MersenneTwister(123), μ₀) 
+    @test rand(MersenneTwister(123), μ) == rand(MersenneTwister(123), μ₀)
     x = rand()
     @test logdensity_def(μ, x) == log(w)
     @test logdensityof(μ, x) == logdensityof(μ₀, x)

test/runtests.jl

@@ -20,7 +20,6 @@ d = ∫exp(x -> -x^2, Lebesgue(ℝ))
 #     return (x,y)
 # end
 
-
 test_measures = [
     # Chain(x -> Normal(μ=x), Normal(μ=0.0))
     # For(3) do j
@@ -53,8 +52,8 @@ testbroken_measures = [
     for μ in test_measures
         @info "testing $μ"
         test_interface(μ)
-        test_interface(μ ^ 3)
-        test_interface(μ ^ (3,2))
+        test_interface(μ^3)
+        test_interface(μ^(3, 2))
         test_interface(5 * μ)
         # test_interface(SpikeMixture(μ, 0.2))
     end
@@ -105,10 +104,9 @@ end
 #     end
 # end
 
-
 @testset "powers" begin
-    @test logdensityof(Lebesgue() ^ 3, 2) == logdensityof(Lebesgue() ^ (3,), 2)
-    @test logdensityof(Lebesgue() ^ 3, 2) == logdensityof(Lebesgue() ^ (3,1), (2,0))
+    @test logdensityof(Lebesgue()^3, 2) == logdensityof(Lebesgue()^(3,), 2)
+    @test logdensityof(Lebesgue()^3, 2) == logdensityof(Lebesgue()^(3, 1), (2, 0))
 end
 
 @testset "Half" begin
@@ -176,41 +174,41 @@ end
 end
 
 @testset "logdensity_rel" begin
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Dirac(1.0), 0.0) == Inf
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Dirac(1.0), 1.0) == -Inf
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Dirac(1.0), 2.0) == Inf
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Dirac(0.0), 0.0) == 0.0
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Dirac(0.0), 1.0) == Inf
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Lebesgue(), 0.0) == Inf
-    @test logdensity_rel(Dirac(0.0)+Lebesgue(), Lebesgue(), 1.0) == 0.0
-
-    @test logdensity_rel(Dirac(1.0), Dirac(0.0)+Lebesgue(), 0.0) == -Inf
-    @test logdensity_rel(Dirac(1.0), Dirac(0.0)+Lebesgue(), 1.0) == Inf
-    @test logdensity_rel(Dirac(1.0), Dirac(0.0)+Lebesgue(), 2.0) == -Inf
-    @test logdensity_rel(Dirac(0.0), Dirac(0.0)+Lebesgue(), 0.0) == 0.0
-    @test logdensity_rel(Dirac(0.0), Dirac(0.0)+Lebesgue(), 1.0) == -Inf
-    @test logdensity_rel(Lebesgue(), Dirac(0.0)+Lebesgue(), 0.0) == -Inf
-    @test logdensity_rel(Lebesgue(), Dirac(0.0)+Lebesgue(), 1.0) == 0.0
-    
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Dirac(1.0), 0.0) == Inf
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Dirac(1.0), 1.0) == -Inf
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Dirac(1.0), 2.0) == Inf
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Dirac(0.0), 0.0) == 0.0
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Dirac(0.0), 1.0) == Inf
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Lebesgue(), 0.0) == Inf
+    @test logdensity_rel(Dirac(0.0) + Lebesgue(), Lebesgue(), 1.0) == 0.0
+
+    @test logdensity_rel(Dirac(1.0), Dirac(0.0) + Lebesgue(), 0.0) == -Inf
+    @test logdensity_rel(Dirac(1.0), Dirac(0.0) + Lebesgue(), 1.0) == Inf
+    @test logdensity_rel(Dirac(1.0), Dirac(0.0) + Lebesgue(), 2.0) == -Inf
+    @test logdensity_rel(Dirac(0.0), Dirac(0.0) + Lebesgue(), 0.0) == 0.0
+    @test logdensity_rel(Dirac(0.0), Dirac(0.0) + Lebesgue(), 1.0) == -Inf
+    @test logdensity_rel(Lebesgue(), Dirac(0.0) + Lebesgue(), 0.0) == -Inf
+    @test logdensity_rel(Lebesgue(), Dirac(0.0) + Lebesgue(), 1.0) == 0.0
+
     @test isnan(logdensity_rel(Dirac(0), Dirac(1), 2))
 end
 
 @testset "Density measures and Radon-Nikodym" begin
     x = randn()
     f(x) = x^2
-    @test  logdensityof(𝒹(∫exp(f, Lebesgue()), Lebesgue()),x ) ≈ f(x)
+    @test logdensityof(𝒹(∫exp(f, Lebesgue()), Lebesgue()), x) ≈ f(x)
 
     let f = 𝒹(∫exp(x -> x^2, Lebesgue()), Lebesgue())
-        @test logdensityof(f,x) ≈ x^2
+        @test logdensityof(f, x) ≈ x^2
     end
 
-#     let d = ∫exp(log𝒹(Cauchy(), Normal()), Normal())
-#         @test logdensity_def(d, x) ≈ logdensity_def(Cauchy(), x) 
-#     end
+    #     let d = ∫exp(log𝒹(Cauchy(), Normal()), Normal())
+    #         @test logdensity_def(d, x) ≈ logdensity_def(Cauchy(), x) 
+    #     end
 
-#     let f = log𝒹(∫exp(x -> x^2, Normal()), Normal())
-#         @test f(x) ≈ x^2
-#     end
+    #     let f = log𝒹(∫exp(x -> x^2, Normal()), Normal())
+    #         @test f(x) ≈ x^2
+    #     end
 end
 
 include("combinators/weighted.jl")