Added `empty

 * `empty` returns an `Associative` with no keys, replacing `similar`.
 * Also `empty(::Tuple) = ()` and `empty(::Array{T}) = T[]`.

Author: Andy Ferris

NEWS.md

@@ -1257,6 +1257,13 @@ Deprecated or removed
 
   * `EnvHash` has been renamed to `EnvDict` ([#24167]).
 
+  * Introduced the `empty` function, the functional pair to `empty!` which returns a new,
+    empty container ([#24390]).
+
+  * `similar(::Associative)` has been deprecated in favor of `empty(::Associative)`, and
+    `similar(::Associative, ::Pair{K, V})` has been deprecated in favour of
+    `empty(::Associative, K, V)` ([#24390]).
+
 Command-line option changes
 ---------------------------
 

base/abstractarray.jl

@@ -563,8 +563,26 @@ of the columns of `A`.
 would create an array of `Int`, initialized to zero, matching the
 indices of `A`.
 """
-similar(f, shape::Tuple) = f(to_shape(shape))
-similar(f, dims::DimOrInd...) = similar(f, dims)
+similar(f, shape::Tuple) = f(to_shape(shape))    # doesn't share well with Associative
+similar(f, dims::DimOrInd...) = similar(f, dims) # doesn't share well with Associative
+
+"""
+    empty(v::AbstractVector, [eltype])
+
+Create an empty vector similar to `v`, optionally changing the `eltype`.
+
+# Examples
+
+```jldoctest
+julia> empty([1.0, 2.0, 3.0])
+0-element Array{Float64,1}
+
+julia> empty([1.0, 2.0, 3.0], String)
+0-element Array{String,1}
+```
+"""
+empty(a::AbstractVector) = empty(a, eltype(a))
+empty(a::AbstractVector, ::Type{T}) where {T} = Vector{T}()
 
 ## from general iterable to any array
 

base/associative.jl

@@ -136,8 +136,42 @@ This includes arrays, where the keys are the array indices.
 """
 pairs(collection) = Generator(=>, keys(collection), values(collection))
 
+"""
+    similar(a::Associative, [value_type=valtype(a)], [inds=keys(a)])
+
+Create an `Associative` container with unitialized values of `value_type` and indices
+`inds`. The second and third arguments are optional and default to the input's `valtype` and
+`keys`, respectively.
+
+Custom `Associative` subtypes may choose which specific associative type is best suited to
+return for the given value type and indices, by specializing on the three-argument
+signature. The default is to return a `Dict`.
+"""
+# v1.0: similar(a::Associative) = similar(a, valtype(a), keys(a))
+similar(a::Associative, ::Type{T}) where {T} = similar(a, T, keys(a))
+similar(a::Associative, inds) = similar(a, valtype(a), inds)
+
+# disambiguation
+similar(a::Associative, t::Tuple) = similar(a, valtype(a), t)
+similar(a::Associative, d::DimOrInd) = similar(a, valtype(a), d)
+
+"""
+    empty(a::Associative, [index_type=keytype(a)], [value_type=valtype(a)])
+
+Create an empty `Associative` container which can accept indices of type `index_type` and
+values of type `value_type`. The second and third arguments are optional and default to the
+input's `keytype` and `valtype`, respectively. (If only one of the two types is specified,
+it is assumed to be the `value_type`, and the `index_type` we default to `keytype(a)`).
+
+Custom `Associative` subtypes may choose which specific associative type is best suited to
+return for the given index and value types, by specializing on the three-argument signature.
+The default is to return an empty `Dict`.
+"""
+empty(a::Associative) = empty(a, keytype(a), valtype(a))
+empty(a::Associative, ::Type{V}) where {V} = empty(a, keytype(a), V) # Note: this is the form which makes sense for `Vector`.
+
 function copy(a::Associative)
-    b = similar(a)
+    b = empty(a)
     for (k,v) in a
         b[k] = v
     end
@@ -403,7 +437,7 @@ Dict{Int64,String} with 1 entry:
 """
 function filter(f, d::Associative)
     # don't just do filter!(f, copy(d)): avoid making a whole copy of d
-    df = similar(d)
+    df = empty(d)
     try
         for (k, v) in d
             if f(k => v)
@@ -512,7 +546,7 @@ mutable struct ObjectIdDict <: Associative{Any,Any}
     ObjectIdDict(o::ObjectIdDict) = new(copy(o.ht))
 end
 
-similar(d::ObjectIdDict) = ObjectIdDict()
+empty(d::ObjectIdDict, ::Type{Any}, ::Type{Any}) = ObjectIdDict()
 
 function rehash!(t::ObjectIdDict, newsz = length(t.ht))
     t.ht = ccall(:jl_idtable_rehash, Any, (Any, Csize_t), t.ht, newsz)

base/deepcopy.jl

@@ -105,7 +105,7 @@ function deepcopy_internal(x::Dict, stackdict::ObjectIdDict)
         return (stackdict[x] = copy(x))
     end
 
-    dest = similar(x)
+    dest = empty(x)
     stackdict[x] = dest
     for (k, v) in x
         dest[deepcopy_internal(k, stackdict)] = deepcopy_internal(v, stackdict)

base/deprecated.jl

@@ -2097,6 +2097,10 @@ end
     @deprecate chol!(x::Number, uplo) chol(x) false
 end
 
+# issue #24019
+@deprecate similar(a::Associative) empty(a)
+@deprecate similar(a::Associative, ::Type{Pair{K,V}}) where {K, V} empty(a, K, V)
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/dict.jl

@@ -111,6 +111,9 @@ mutable struct Dict{K,V} <: Associative{K,V}
         new(copy(d.slots), copy(d.keys), copy(d.vals), 0, d.count, d.age, d.idxfloor,
             d.maxprobe)
     end
+    function Dict{K, V}(slots, keys, ndel, count, age, idxfloor, maxprobe) where {K, V}
+        new(slots, keys, Vector{V}(length(keys)), ndel, count, age, idxfloor, maxprobe)
+    end
 end
 function Dict{K,V}(kv) where V where K
     h = Dict{K,V}()
@@ -170,7 +173,7 @@ end
 # this is a special case due to (1) allowing both Pairs and Tuples as elements,
 # and (2) Pair being invariant. a bit annoying.
 function grow_to!(dest::Associative, itr)
-    out = grow_to!(similar(dest, Pair{Union{},Union{}}), itr, start(itr))
+    out = grow_to!(empty(dest, Union{}, Union{}), itr, start(itr))
     return isempty(out) ? dest : out
 end
 
@@ -180,7 +183,7 @@ function grow_to!(dest::Associative{K,V}, itr, st) where V where K
         if isa(k,K) && isa(v,V)
             dest[k] = v
         else
-            new = similar(dest, Pair{typejoin(K,typeof(k)), typejoin(V,typeof(v))})
+            new = empty(dest, typejoin(K,typeof(k)), typejoin(V,typeof(v)))
             copy!(new, dest)
             new[k] = v
             return grow_to!(new, itr, st)
@@ -189,8 +192,23 @@ function grow_to!(dest::Associative{K,V}, itr, st) where V where K
     return dest
 end
 
-similar(d::Dict{K,V}) where {K,V} = Dict{K,V}()
-similar(d::Dict, ::Type{Pair{K,V}}) where {K,V} = Dict{K,V}()
+function similar(a::Associative, ::Type{V}, inds) where {V}
+    K = eltype(inds)
+    tmp = Dict{K, Void}()
+    for i in inds
+        tmp[i] = nothing
+    end
+    return Dict{K, V}(tmp.slots, tmp.keys, tmp.ndel, tmp.count, tmp.age,
+                      tmp.idxfloor, tmp.maxprobe)
+end
+
+# Fast copy of hashed indices from a `Dict`
+function similar(a::Associative, ::Type{V}, inds::KeyIterator{<:Dict{K}}) where {K, V}
+    Dict{K, V}(copy(inds.dict.slots), copy(inds.dict.keys), inds.dict.ndel, inds.dict.count,
+               inds.dict.age, inds.dict.idxfloor, inds.dict.maxprobe)
+end
+
+empty(a::Associative, ::Type{K}, ::Type{V}) where {K, V} = Dict{K, V}()
 
 # conversion between Dict types
 function convert(::Type{Dict{K,V}},d::Associative) where V where K
@@ -813,12 +831,7 @@ next(::ImmutableDict{K,V}, t) where {K,V} = (Pair{K,V}(t.key, t.value), t.parent
 done(::ImmutableDict, t) = !isdefined(t, :parent)
 length(t::ImmutableDict) = count(x->true, t)
 isempty(t::ImmutableDict) = done(t, start(t))
-function similar(t::ImmutableDict)
-    while isdefined(t, :parent)
-        t = t.parent
-    end
-    return t
-end
+empty(::ImmutableDict, ::Type{K}, ::Type{V}) where {K, V} = ImmutableDict{K,V}()
 
-_similar_for(c::Dict, ::Type{P}, itr, isz) where {P<:Pair} = similar(c, P)
+_similar_for(c::Dict, ::Type{Pair{K,V}}, itr, isz) where {K, V} = empty(c, K, V)
 _similar_for(c::Associative, T, itr, isz) = throw(ArgumentError("for Associatives, similar requires an element type of Pair;\n  if calling map, consider a comprehension instead"))

base/env.jl

@@ -73,8 +73,6 @@ variables.
 """
 const ENV = EnvDict()
 
-similar(::EnvDict) = Dict{String,String}()
-
 getindex(::EnvDict, k::AbstractString) = access_env(k->throw(KeyError(k)), k)
 get(::EnvDict, k::AbstractString, def) = access_env(k->def, k)
 get(f::Callable, ::EnvDict, k::AbstractString) = access_env(k->f(), k)

base/exports.jl

@@ -652,6 +652,7 @@ export
     deleteat!,
     eltype,
     empty!,
+    empty,
     endof,
     filter!,
     filter,

base/pkg/query.jl

@@ -42,9 +42,9 @@ end
 
 # Specialized copy for the avail argument below because the deepcopy is slow
 function availcopy(avail)
-    new_avail = similar(avail)
+    new_avail = empty(avail)
     for (pkg, vers_avail) in avail
-        new_vers_avail = similar(vers_avail)
+        new_vers_avail = empty(vers_avail)
         for (version, pkg_avail) in vers_avail
             new_vers_avail[version] = copy(pkg_avail)
         end

base/tuple.jl

@@ -328,3 +328,10 @@ any(x::Tuple{}) = false
 any(x::Tuple{Bool}) = x[1]
 any(x::Tuple{Bool, Bool}) = x[1]|x[2]
 any(x::Tuple{Bool, Bool, Bool}) = x[1]|x[2]|x[3]
+
+"""
+    empty(x::Tuple)
+
+Returns an empty tuple, `()`.
+"""
+empty(x::Tuple) = ()