Introduce sizehint!(s, n; shrink = true) to controll shrinkage

Author: petvana

base/abstractdict.jl

@@ -220,8 +220,7 @@ Dict{Int64, Int64} with 3 entries:
 function merge!(d::AbstractDict, others::AbstractDict...)
     for other in others
         if haslength(d) && haslength(other)
-            # TODO - do not shrink
-            sizehint!(d, length(d) + length(other))
+            sizehint!(d, length(d) + length(other); shrink = false)
         end
         for (k,v) in other
             d[k] = v

base/abstractset.jl

@@ -101,7 +101,7 @@ max_values(::Type{Bool}) = 2
 max_values(::Type{Nothing}) = 1
 
 function union!(s::AbstractSet{T}, itr) where T
-    haslength(itr) && _sizehint!(s, length(s) + Int(length(itr))::Int; shrink = false)
+    haslength(itr) && sizehint!(s, length(s) + Int(length(itr))::Int; shrink = false)
     for x in itr
         push!(s, x)
         length(s) == max_values(T) && break

base/array.jl

@@ -1441,7 +1441,7 @@ function resize!(a::Vector, nl::Integer)
 end
 
 """
-    sizehint!(s, n) -> s
+    sizehint!(s, n; shrink = true) -> s
 
 Suggest that collection `s` reserve capacity for at least `n` elements. That is, if
 you expect that you're going to have to push a lot of values onto `s`, you can avoid
@@ -1462,10 +1462,13 @@ For types that support `sizehint!`,
    `Base`.
 
 3. `empty!` is nearly costless (and O(1)) for types that support this kind of preallocation.
+
+4. `shrink` controls if the collection can be shrunk.
 """
 function sizehint! end
 
 function sizehint!(a::Vector, sz::Integer)
+    # TODO - controll shrinkage
     len = length(a)
     ref = a.ref
     mem = ref.mem
@@ -1494,7 +1497,7 @@ function sizehint!(a::Vector, sz::Integer)
 end
 
 # Fall-back implementation for non-shrinkable collections
-_sizehint!(a, sz; shrink) = sizehint!(a, sz)
+sizehint!(a, sz; shrink) = sizehint!(a, sz)
 
 """
     pop!(collection) -> item

base/dict.jl

@@ -228,7 +228,7 @@ end
     return h
 end
 
-function _sizehint!(d::Dict{T}, newsz; shrink = true) where T
+function sizehint!(d::Dict{T}, newsz; shrink = true) where T
     oldsz = length(d.slots)
     # limit new element count to max_values of the key type
     newsz = min(max(newsz, length(d)), max_values(T)::Int)
@@ -237,8 +237,6 @@ function _sizehint!(d::Dict{T}, newsz; shrink = true) where T
     return (shrink ? newsz == oldsz : newsz <= oldsz) ? d : rehash!(d, newsz)
 end
 
-sizehint!(d::Dict{T}, newsz) where T = _sizehint!(d, newsz)
-
 """
     empty!(collection) -> collection
 
@@ -777,7 +775,7 @@ function map!(f, iter::ValueIterator{<:Dict})
 end
 
 function mergewith!(combine, d1::Dict{K, V}, d2::AbstractDict) where {K, V}
-    haslength(d2) && _sizehint!(d1, length(d1) + length(d2), shrink = false)
+    haslength(d2) && sizehint!(d1, length(d1) + length(d2), shrink = false)
     for (k, v) in d2
         i, sh = ht_keyindex2_shorthash!(d1, k)
         if i > 0

base/weakkeydict.jl

@@ -80,7 +80,7 @@ function _cleanup_locked(h::WeakKeyDict)
     return h
 end
 
-sizehint!(d::WeakKeyDict, newsz) = sizehint!(d.ht, newsz)
+sizehint!(d::WeakKeyDict, newsz; shrink = true) = sizehint!(d.ht, newsz; shrink = shrink)
 empty(d::WeakKeyDict, ::Type{K}, ::Type{V}) where {K, V} = WeakKeyDict{K, V}()
 
 IteratorSize(::Type{<:WeakKeyDict}) = SizeUnknown()

test/dict.jl

@@ -1492,9 +1492,9 @@ end
     sizehint!(d, 10)
     @test length(d.slots) < 100
     sizehint!(d, 1000)
-    Base._sizehint!(d, 1; shrink = false)
+    sizehint!(d, 1; shrink = false)
     @test length(d.slots) >= 1000
-    Base._sizehint!(d, 1; shrink = true)
+    sizehint!(d, 1; shrink = true)
     @test length(d.slots) < 1000
 end