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

base/abstractdict.jl

@@ -701,3 +701,29 @@ function iterate(s::IdSet, state...)
     ((k, _), i) = y
     return (k, i)
 end
+
+"""
+    map!(f, values(dict::AbstractDict))
+Takes the function `f(value) and transforms values stored in `dict` with the transformation `value=f(value).
+
+# 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::Base.ValueIterator{D}) where D <:Base.AbstractDict
+    # 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,20 @@ end
 
 filter!(f, d::Dict) = filter_in_one_pass!(f, d)
 
+function map!(f, iter::ValueIterator{Dict{K,V}}) where {K, V}
+    dict = iter.dict
+    vals = dict.vals
+    i = dict.idxfloor
+    len=length(vals)
+    @inbounds while i < len
+        if !(isslotfilled(dict, i))
+            i += 1; continue
+        end
+        @inbounds vals[i] = f(vals[i])
+        i += 1; continue
+    end
+end
+
 struct ImmutableDict{K,V} <: AbstractDict{K,V}
     parent::ImmutableDict{K,V}
     key::K

base/exports.jl

@@ -506,6 +506,8 @@ export
     length,
     map!,
     map,
+    mapdict!,
+    mapdict,
     mapfoldl,
     mapfoldr,
     mapreduce,

base/weakkeydict.jl

@@ -92,6 +92,7 @@ function getkey(wkh::WeakKeyDict{K}, kk, default) where K
     end
 end
 
+Base.map!(f,iter::Base.ValueIterator{WeakKeyDict{K,V}}) where {K, V} = Base.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