Added implementation of getnull(coll, key) for Associative.

This returns a Nullable value corresponding to the key (or null).
Includes specialization for dictionaries.
Fixes #13055

Author: dbeach24

base/dict.jl

@@ -6,6 +6,13 @@ const secret_table_token = :__c782dbf1cf4d6a2e5e3865d7e95634f2e09b5902__
 
 haskey(d::Associative, k) = in(k,keys(d))
 
+"""
+    getnull(d::Associative, key)
+
+Return Nullable(`value`) corresponding to `key` if present, otherwise null.
+"""
+getnull{K,V}(d::Associative{K,V}, k) = haskey(d, k) ? Nullable{V}(d[k]::V) : Nullable{V}()
+
 function in(p::Pair, a::Associative, valcmp=(==))
     v = get(a,p[1],secret_table_token)
     if !is(v, secret_table_token)
@@ -698,6 +705,11 @@ function get{K,V}(default::Callable, h::Dict{K,V}, key)
     return (index < 0) ? default() : h.vals[index]::V
 end
 
+function getnull{K,V}(h::Dict{K,V}, key)
+    index = ht_keyindex(h, key)
+    return (index<0) ? Nullable{V}() : Nullable{V}(h.vals[index]::V)
+end
+
 haskey(h::Dict, key) = (ht_keyindex(h, key) >= 0)
 in{T<:Dict}(key, v::KeyIterator{T}) = (ht_keyindex(v.dict, key) >= 0)
 
@@ -828,6 +840,7 @@ function getindex(dict::ImmutableDict, key)
     end
     throw(KeyError(key))
 end
+
 function get(dict::ImmutableDict, key, default)
     while isdefined(dict, :parent)
         dict.key == key && return dict.value
@@ -836,6 +849,14 @@ function get(dict::ImmutableDict, key, default)
     return default
 end
 
+function getnull{K,V}(dict::ImmutableDict{K,V}, key)
+    while isdefined(dict, :parent)
+        dict.key == key && return Nullable{V}(dict.value::V)
+        dict = dict.parent
+    end
+    Nullable{V}()
+end
+
 # this actually defines reverse iteration (e.g. it should not be used for merge/copy/filter type operations)
 start(t::ImmutableDict) = t
 next{K,V}(::ImmutableDict{K,V}, t) = (Pair{K,V}(t.key, t.value), t.parent)

base/exports.jl

@@ -749,6 +749,7 @@ export
     get!,
     getindex,
     getkey,
+    getnull,
     haskey,
     in,
     intersect!,

base/weakkeydict.jl

@@ -42,6 +42,7 @@ get{K}(wkh::WeakKeyDict{K}, key, default) = lock(() -> get(wkh.ht, key, default)
 get{K}(default::Callable, wkh::WeakKeyDict{K}, key) = lock(() -> get(default, wkh.ht, key), wkh)
 get!{K}(wkh::WeakKeyDict{K}, key, default) = lock(() -> get!(wkh.ht, key, default), wkh)
 get!{K}(default::Callable, wkh::WeakKeyDict{K}, key) = lock(() -> get!(default, wkh.ht, key), wkh)
+getnull{K}(wkh::WeakKeyDict{K}, key) = lock(() -> getnull(wkh.ht, key), wkh)
 pop!{K}(wkh::WeakKeyDict{K}, key) = lock(() -> pop!(wkh.ht, key), wkh)
 pop!{K}(wkh::WeakKeyDict{K}, key, default) = lock(() -> pop!(wkh.ht, key, default), wkh)
 delete!{K}(wkh::WeakKeyDict{K}, key) = lock(() -> delete!(wkh.ht, key), wkh)

test/dict.jl

@@ -256,6 +256,10 @@ let f(x) = x^2, d = Dict(8=>19)
         f(4)
     end == 16
 
+    # getnull (returns Nullable)
+    @test get(getnull(d, 8)) == 19
+    @test isnull(getnull(d, 13))
+
     @test d == Dict(8=>19, 19=>2, 42=>4)
 end
 
@@ -452,6 +456,10 @@ let d = ImmutableDict{String, String}(),
     @test get(d4, "key1", :default) === v2
     @test get(d4, "foo", :default) === :default
     @test get(d, k1, :default) === :default
+    @test getnull(d1, "key1") === Nullable{String}(v1)
+    @test getnull(d4, "key1") === Nullable{String}(v2)
+    @test getnull(d4, "foo") === Nullable{String}()
+    @test getnull(d, k1) === Nullable{String}()
     @test d1["key1"] === v1
     @test d4["key1"] === v2
     @test similar(d3) === d