Added implementation of tryget(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,14 @@ const secret_table_token = :__c782dbf1cf4d6a2e5e3865d7e95634f2e09b5902__
 
 haskey(d::Associative, k) = in(k,keys(d))
 
+"""
+    tryget(collection, key)
+
+Return the value stored for the given key as `Nullable(value)`,
+or if no mapping for the key is present, return null.
+"""
+tryget{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 +706,11 @@ function get{K,V}(default::Callable, h::Dict{K,V}, key)
     return (index < 0) ? default() : h.vals[index]::V
 end
 
+function tryget{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 +841,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 +850,14 @@ function get(dict::ImmutableDict, key, default)
     return default
 end
 
+function tryget{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

@@ -777,6 +777,7 @@ export
     splice!,
     symdiff!,
     symdiff,
+    tryget,
     union!,
     union,
     unique,

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)
+tryget{K}(wkh::WeakKeyDict{K}, key) = lock(() -> tryget(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)

doc/stdlib/collections.rst

@@ -1008,6 +1008,12 @@ Given a dictionary ``D``, the syntax ``D[x]`` returns the value of key ``x`` (if
            time()
        end
 
+.. function:: tryget(collection, key)
+
+   .. Docstring generated from Julia source
+
+   Return the value stored for the given key as ``Nullable(value)``\ , or if no mapping for the key is present, return null.
+
 .. function:: get!(collection, key, default)
 
    .. Docstring generated from Julia source

test/dict.jl

@@ -256,6 +256,10 @@ let f(x) = x^2, d = Dict(8=>19)
         f(4)
     end == 16
 
+    # tryget (returns Nullable)
+    @test get(tryget(d, 8)) == 19
+    @test isnull(tryget(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 tryget(d1, "key1") === Nullable{String}(v1)
+    @test tryget(d4, "key1") === Nullable{String}(v2)
+    @test tryget(d4, "foo") === Nullable{String}()
+    @test tryget(d, k1) === Nullable{String}()
     @test d1["key1"] === v1
     @test d4["key1"] === v2
     @test similar(d3) === d