RFC/WIP: creation of mapdict method to modify Dict values

base/abstractdict.jl

@@ -701,3 +701,32 @@ function iterate(s::IdSet, state...)
     ((k, _), i) = y
     return (k, i)
 end
+
+"""
+    map!(f, values(dict::AbstractDict))
+
+Modifies `dict` by transforming each value from `val` to `f(val)`.
+Note that the type of `dict` cannot be changed: if `f(val)` is not an instance of the key type
+of `dict` then it will be converted to the key type if possible and otherwise raise an error.
+
+# Examples
+```jldoctest
+julia> d = Dict(:a => 1, :b => 2)
+Dict{Symbol,Int64} with 2 entries:
+  :a => 1
+  :b => 2
+
+julia> map!(v -> v-1, values(d))
+Dict{Symbol,Int64} with 2 entries:
+  :a => 0
+  :b => 1
+ ```
+"""
+function map!(f, iter::ValueIterator)
+    # This is the naive fallback which requires hash evaluations
+    # Contrary to the example Dict has an implementation which does not require hash evaluations
+    dict = iter.dict
+    for (key, val) in pairs(dict)
+        dict[key] = f(val)
+    end
+end

base/dict.jl

@@ -686,6 +686,18 @@ end
 
 filter!(f, d::Dict) = filter_in_one_pass!(f, d)
 
+function map!(f, iter::ValueIterator{<:Dict})
+    dict = iter.dict
+    vals = dict.vals
+    # @inbounds is here so the it gets propigated to isslotfiled
+    @inbounds for i = dict.idxfloor:lastindex(vals)
+        if isslotfilled(dict, i)
+            vals[i] = f(vals[i])
+        end
+    end
+    return vals
+end
+
 struct ImmutableDict{K,V} <: AbstractDict{K,V}
     parent::ImmutableDict{K,V}
     key::K

base/weakkeydict.jl

@@ -92,6 +92,7 @@ function getkey(wkh::WeakKeyDict{K}, kk, default) where K
     end
 end
 
+map!(f,iter::ValueIterator{<:WeakKeyDict})= map!(f, values(iter.dict.ht))
 get(wkh::WeakKeyDict{K}, key, default) where {K} = lock(() -> get(wkh.ht, key, default), wkh)
 get(default::Callable, wkh::WeakKeyDict{K}, key) where {K} = lock(() -> get(default, wkh.ht, key), wkh)
 function get!(wkh::WeakKeyDict{K}, key, default) where {K}

test/dict.jl

@@ -1021,3 +1021,28 @@ end
         end
     end
 end
+
+@testset "map!(f, values(dict))" begin
+    @testset "AbstractDict & Fallback" begin
+        mutable struct TestDict{K, V}  <: AbstractDict{K, V}
+            dict::Dict{K, V}
+            function TestDict(args...)
+                d = Dict(args...)
+                new{keytype(d), valtype(d)}(d)
+            end
+        end
+        Base.setindex!(td::TestDict, args...) = setindex!(td.dict, args...)
+        Base.getindex(td::TestDict, args...) = getindex(td.dict, args...)
+        Base.pairs(D::TestDict) = pairs(D.dict)
+        testdict = TestDict(:a=>1, :b=>2)
+        map!(v->v-1, values(testdict))
+        @test testdict[:a] == 0
+        @test testdict[:b] == 1
+    end
+    @testset "Dict" begin
+        testdict = Dict(:a=>1, :b=>2)
+        map!(v->v-1, values(testdict))
+        @test testdict[:a] == 0
+        @test testdict[:b] == 1
+    end
+end