Make hasvalue and getvalue use the most specific value

Author: penelopeysm

HISTORY.md

@@ -1,3 +1,16 @@
+## 0.12.1
+
+Minimum compatibility has been bumped to Julia 1.10.
+
+Added the new functions `hasvalue(container::T, ::VarName[, ::Distribution])` and `getvalue(container::T, ::VarName[, ::Distribution])`, where `T` is either `NamedTuple` or `AbstractDict{<:VarName}`.
+
+These functions check whether a given `VarName` has a value in the given `NamedTuple` or `AbstractDict`, and return the value if it exists.
+
+The optional `Distribution` argument allows one to reconstruct a full value from its component indices.
+For example, if `container` has `x[1]` and `x[2]`, then `hasvalue(container, @varname(x), dist)` will return true if `size(dist) == (2,)` (for example, `MvNormal(zeros(2), I)`).
+
+These functions (without the `Distribution` argument) were previously in DynamicPPL.jl (albeit unexported).
+
 ## 0.12.0
 
 ### VarName constructors

Project.toml

@@ -3,7 +3,7 @@ uuid = "7a57a42e-76ec-4ea3-a279-07e840d6d9cf"
 keywords = ["probablistic programming"]
 license = "MIT"
 desc = "Common interfaces for probabilistic programming"
-version = "0.12.0"
+version = "0.12.1"
 
 [deps]
 AbstractMCMC = "80f14c24-f653-4e6a-9b94-39d6b0f70001"

src/hasvalue.jl

@@ -117,26 +117,27 @@ function getvalue(vals::AbstractDict{<:VarName}, vn::VarName{sym}) where {sym}
     # First we check if `vn` is present as is.
     haskey(vals, vn) && return vals[vn]
 
-    # Otherwise, we start by testing the bare `vn` (e.g., if `vn` is `x[1][2]`,
-    # we start by checking if `x` is present). We will then keep adding optics
-    # to `test_optic`, either until we find a key that is present, or until we
-    # run out of optics to test (which is determined by _inner(test_optic) ==
-    # identity).
-    test_vn = VarName{sym}()
-    test_optic = getoptic(vn)
-
-    while _inner(test_optic) != identity
+    # Otherwise, we start by testing the `vn` one level up (e.g., if `vn` is
+    # `x[1][2]`, we start by checking if `x[1]` is present, then `x`). We will
+    # then keep removing optics from `test_optic`, either until we find a key
+    # that is present, or until we run out of optics to test (which happens 
+    # after getoptic(test_vn) == identity).
+    o = getoptic(vn)
+    test_vn = VarName{sym}(_init(o))
+    test_optic = _last(o)
+
+    while true
         if haskey(vals, test_vn) && canview(test_optic, vals[test_vn])
             return test_optic(vals[test_vn])
         else
-            # Move the innermost optic into test_vn
-            test_optic_outer = _outer(test_optic)
-            test_optic_inner = _inner(test_optic)
-            test_vn = VarName{sym}(test_optic_inner ∘ getoptic(test_vn))
-            test_optic = test_optic_outer
+            # Try to move the outermost optic from test_vn into test_optic.
+            # If test_vn is already an identity, we can't, so we stop.
+            o = getoptic(test_vn)
+            o == identity && error("getvalue: $(vn) was not found in the values provided")
+            test_vn = VarName{sym}(_init(o))
+            test_optic = normalise(_last(o) ∘ test_optic)
         end
     end
-    return error("getvalue: $(vn) was not found in the values provided")
 end
 
 """
@@ -209,23 +210,25 @@ function hasvalue(vals::AbstractDict{<:VarName}, vn::VarName{sym}) where {sym}
     # First we check if `vn` is present as is.
     haskey(vals, vn) && return true
 
-    # Otherwise, we start by testing the bare `vn` (e.g., if `vn` is `x[1][2]`,
-    # we start by checking if `x` is present). We will then keep adding optics
-    # to `test_optic`, either until we find a key that is present, or until we
-    # run out of optics to test (which is determined by _inner(test_optic) ==
-    # identity).
-    test_vn = VarName{sym}()
-    test_optic = getoptic(vn)
+    # Otherwise, we start by testing the `vn` one level up (e.g., if `vn` is
+    # `x[1][2]`, we start by checking if `x[1]` is present, then `x`). We will
+    # then keep removing optics from `test_optic`, either until we find a key
+    # that is present, or until we run out of optics to test (which happens 
+    # after getoptic(test_vn) == identity).
+    o = getoptic(vn)
+    test_vn = VarName{sym}(_init(o))
+    test_optic = _last(o)
 
-    while _inner(test_optic) != identity
+    while true
         if haskey(vals, test_vn) && canview(test_optic, vals[test_vn])
             return true
         else
-            # Move the innermost optic into test_vn
-            test_optic_outer = _outer(test_optic)
-            test_optic_inner = _inner(test_optic)
-            test_vn = VarName{sym}(test_optic_inner ∘ getoptic(test_vn))
-            test_optic = test_optic_outer
+            # Try to move the outermost optic from test_vn into test_optic.
+            # If test_vn is already an identity, we can't, so we stop.
+            o = getoptic(test_vn)
+            o == identity && return false
+            test_vn = VarName{sym}(_init(o))
+            test_optic = normalise(_last(o) ∘ test_optic)
         end
     end
     return false

src/varname.jl

@@ -963,69 +963,131 @@ string_to_varname(str::AbstractString) = dict_to_varname(JSON.parse(str))
 ### Prefixing and unprefixing
 
 """
-    _strip_identity(optic)
+    _head(optic)
 
-Remove identity lenses from composed optics.
-"""
-_strip_identity(::Base.ComposedFunction{typeof(identity),typeof(identity)}) = identity
-function _strip_identity(o::Base.ComposedFunction{Outer,typeof(identity)}) where {Outer}
-    return _strip_identity(o.outer)
-end
-function _strip_identity(o::Base.ComposedFunction{typeof(identity),Inner}) where {Inner}
-    return _strip_identity(o.inner)
-end
-_strip_identity(o::Base.ComposedFunction) = o
-_strip_identity(o::Accessors.PropertyLens) = o
-_strip_identity(o::Accessors.IndexLens) = o
-_strip_identity(o::typeof(identity)) = o
-
-"""
-    _inner(optic)
+Get the innermost layer of an optic.
 
-Get the innermost (non-identity) layer of an optic.
+!!! note
+    Does not perform optic normalisation. You may wish to call
+    `normalise(optic)` before using this function if the optic you are passing
+    was not obtained from a VarName.
 
 ```jldoctest; setup=:(using Accessors)
-julia> AbstractPPL._inner(Accessors.@o _.a.b.c)
+julia> AbstractPPL._head(Accessors.@o _.a.b.c)
 (@o _.a)
 
-julia> AbstractPPL._inner(Accessors.@o _[1][2][3])
+julia> AbstractPPL._head(Accessors.@o _[1][2][3])
 (@o _[1])
 
-julia> AbstractPPL._inner(Accessors.@o _)
+julia> AbstractPPL._head(Accessors.@o _.a)
+(@o _.a)
+
+julia> AbstractPPL._head(Accessors.@o _[1])
+(@o _[1])
+
+julia> AbstractPPL._head(Accessors.@o _)
 identity (generic function with 1 method)
 ```
 """
-_inner(o::Base.ComposedFunction{Outer,Inner}) where {Outer,Inner} = o.inner
-_inner(o::Accessors.PropertyLens) = o
-_inner(o::Accessors.IndexLens) = o
-_inner(o::typeof(identity)) = o
+_head(o::ComposedFunction{Outer,Inner}) where {Outer,Inner} = o.inner
+_head(o::Accessors.PropertyLens) = o
+_head(o::Accessors.IndexLens) = o
+_head(::typeof(identity)) = identity
 
 """
-    _outer(optic)
+    _tail(optic)
+
+Get everything but the innermost layer of an optic.
 
-Get the outer layer of an optic.
+!!! note
+    Does not perform optic normalisation. You may wish to call
+    `normalise(optic)` before using this function if the optic you are passing
+    was not obtained from a VarName.
 
 ```jldoctest; setup=:(using Accessors)
-julia> AbstractPPL._outer(Accessors.@o _.a.b.c)
+julia> AbstractPPL._tail(Accessors.@o _.a.b.c)
 (@o _.b.c)
 
-julia> AbstractPPL._outer(Accessors.@o _[1][2][3])
+julia> AbstractPPL._tail(Accessors.@o _[1][2][3])
 (@o _[2][3])
 
-julia> AbstractPPL._outer(Accessors.@o _.a)
+julia> AbstractPPL._tail(Accessors.@o _.a)
 identity (generic function with 1 method)
 
-julia> AbstractPPL._outer(Accessors.@o _[1])
+julia> AbstractPPL._tail(Accessors.@o _[1])
 identity (generic function with 1 method)
 
-julia> AbstractPPL._outer(Accessors.@o _)
+julia> AbstractPPL._tail(Accessors.@o _)
 identity (generic function with 1 method)
 ```
 """
-_outer(o::Base.ComposedFunction{Outer,Inner}) where {Outer,Inner} = o.outer
-_outer(::Accessors.PropertyLens) = identity
-_outer(::Accessors.IndexLens) = identity
-_outer(::typeof(identity)) = identity
+_tail(o::ComposedFunction{Outer,Inner}) where {Outer,Inner} = o.outer
+_tail(::Accessors.PropertyLens) = identity
+_tail(::Accessors.IndexLens) = identity
+_tail(::typeof(identity)) = identity
+
+"""
+    _last(optic)
+
+Get the outermost layer of an optic.
+
+!!! note
+    Does not perform optic normalisation. You may wish to call
+    `normalise(optic)` before using this function if the optic you are passing
+    was not obtained from a VarName.
+
+```jldoctest; setup=:(using Accessors)
+julia> AbstractPPL._last(Accessors.@o _.a.b.c)
+(@o _.c)
+
+julia> AbstractPPL._last(Accessors.@o _[1][2][3])
+(@o _[3])
+
+julia> AbstractPPL._last(Accessors.@o _.a)
+(@o _.a)
+
+julia> AbstractPPL._last(Accessors.@o _[1])
+(@o _[1])
+
+julia> AbstractPPL._last(Accessors.@o _)
+identity (generic function with 1 method)
+```
+"""
+_last(o::ComposedFunction{Outer,Inner}) where {Outer,Inner} = _last(o.outer)
+_last(o::Accessors.PropertyLens) = o
+_last(o::Accessors.IndexLens) = o
+_last(::typeof(identity)) = identity
+
+"""
+    _init(optic)
+
+Get everything but the outermost layer of an optic.
+
+!!! note
+    Does not perform optic normalisation. You may wish to call
+    `normalise(optic)` before using this function if the optic you are passing
+    was not obtained from a VarName.
+
+```jldoctest; setup=:(using Accessors)
+julia> AbstractPPL._init(Accessors.@o _.a.b.c)
+(@o _.a.b)
+
+julia> AbstractPPL._init(Accessors.@o _[1][2][3])
+(@o _[1][2])
+
+julia> AbstractPPL._init(Accessors.@o _.a)
+identity (generic function with 1 method)
+
+julia> AbstractPPL._init(Accessors.@o _[1])
+identity (generic function with 1 method)
+
+julia> AbstractPPL._init(Accessors.@o _)
+identity (generic function with 1 method)
+"""
+_init(o::ComposedFunction{Outer,Inner}) where {Outer,Inner} = _init(o.outer) ∘ o.inner
+_init(::Accessors.PropertyLens) = identity
+_init(::Accessors.IndexLens) = identity
+_init(::typeof(identity)) = identity
 
 """
     optic_to_vn(optic)
@@ -1058,11 +1120,11 @@ function optic_to_vn(::Accessors.PropertyLens{sym}) where {sym}
     return VarName{sym}()
 end
 function optic_to_vn(
-    o::Base.ComposedFunction{Outer,Accessors.PropertyLens{sym}}
+    o::ComposedFunction{Outer,Accessors.PropertyLens{sym}}
 ) where {Outer,sym}
     return VarName{sym}(o.outer)
 end
-optic_to_vn(o::Base.ComposedFunction) = optic_to_vn(normalise(o))
+optic_to_vn(o::ComposedFunction) = optic_to_vn(normalise(o))
 function optic_to_vn(@nospecialize(o))
     msg = "optic_to_vn: could not convert optic `$o` to a VarName"
     throw(ArgumentError(msg))
@@ -1077,14 +1139,14 @@ function unprefix_optic(optic, optic_prefix)
     optic = normalise(optic)
     optic_prefix = normalise(optic_prefix)
     # strip one layer of the optic and check for equality
-    inner = _inner(optic)
-    inner_prefix = _inner(optic_prefix)
-    if inner != inner_prefix
+    head = _head(optic)
+    head_prefix = _head(optic_prefix)
+    if head != head_prefix
         msg = "could not remove prefix $(optic_prefix) from optic $(optic)"
         throw(ArgumentError(msg))
     end
     # recurse
-    return unprefix_optic(_outer(optic), _outer(optic_prefix))
+    return unprefix_optic(_tail(optic), _tail(optic_prefix))
 end
 
 """

test/hasvalue.jl

@@ -1,5 +1,5 @@
 @testset "base getvalue + hasvalue" begin
-    @testset "NamedTuple" begin
+    @testset "basic NamedTuple" begin
         nt = (a=[1], b=2, c=(x=3,), d=[1.0 0.5; 0.5 1.0])
         @test hasvalue(nt, @varname(a))
         @test getvalue(nt, @varname(a)) == [1]
@@ -32,8 +32,8 @@
         @test !hasvalue(nt, @varname(d[3, :]))
     end
 
-    @testset "Dict" begin
-        # same tests as above
+    @testset "basic Dict" begin
+        # same tests as for NamedTuple
         d = Dict(
             @varname(a) => [1],
             @varname(b) => 2,
@@ -68,8 +68,9 @@
         @test !hasvalue(d, @varname(c.x[1]))
         @test !hasvalue(d, @varname(c.y))
         @test !hasvalue(d, @varname(d[1, 3]))
+    end
 
-        # extra ones since Dict can have weird keys
+    @testset "Dict with non-identity varname keys" begin
         d = Dict(
             @varname(a[1]) => [1.0, 2.0],
             @varname(b.x) => [3.0],
@@ -98,6 +99,27 @@
         @test !hasvalue(d, @varname(c[1]))
         @test !hasvalue(d, @varname(c[2].x))
     end
+
+    @testset "Dict with redundancy" begin
+        d1 = Dict(@varname(x) => [[[[1.0]]]])
+        d2 = Dict(@varname(x[1]) => [[[2.0]]])
+        d3 = Dict(@varname(x[1][1]) => [[3.0]])
+        d4 = Dict(@varname(x[1][1][1]) => [4.0])
+        d5 = Dict(@varname(x[1][1][1][1]) => 5.0)
+
+        d = Dict{VarName,Any}()
+        for (new_dict, expected_value) in
+            zip((d1, d2, d3, d4, d5), (1.0, 2.0, 3.0, 4.0, 5.0))
+            d = merge(d, new_dict)
+            @test hasvalue(d, @varname(x[1][1][1][1]))
+            @test getvalue(d, @varname(x[1][1][1][1])) == expected_value
+            # for good measure
+            @test !hasvalue(d, @varname(x[1][1][1][2]))
+            @test !hasvalue(d, @varname(x[1][1][2][1]))
+            @test !hasvalue(d, @varname(x[1][2][1][1]))
+            @test !hasvalue(d, @varname(x[2][1][1][1]))
+        end
+    end
 end
 
 @testset "with Distributions: getvalue + hasvalue" begin