Made less breaking, added news, empty works on more containers.

Author: Andy Ferris

NEWS.md

@@ -1241,6 +1241,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

@@ -566,6 +566,24 @@ indices of `A`.
 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
 
 function copy!(dest::AbstractArray, src)

base/associative.jl

@@ -147,10 +147,14 @@ Custom `Associative` subtypes may choose which specific associative type is best
 return for the given value type and indices, by specializing on the three-argument
 signature. The default is to return a `Dict`.
 """
-similar(a::Associative) = similar(a, valtype(a), keys(a))
+# 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)])
 

base/deprecated.jl

@@ -2074,6 +2074,7 @@ end
 @deprecate EnvHash EnvDict
 
 # 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

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) = ()

test/abstractarray.jl

@@ -870,5 +870,17 @@ end
     Base.convert(::Type{Array{T,n}}, a::Array{T,n}) where {T<:Number,n} = a
     Base.convert(::Type{Array{T,n}}, a::Array) where {T<:Number,n} =
         copy!(Array{T,n}(size(a)), a)
-    @test isa(similar(Dict(:a=>1, :b=>2.0), Pair{Union{},Union{}}), Dict{Union{}, Union{}})
-end
+    @test isa(empty(Dict(:a=>1, :b=>2.0), Union{}, Union{}), Dict{Union{}, Union{}})
+end
+
+@testset "empty" begin
+    @test isempty([])
+    v = [1, 2, 3]
+    v2 = empty(v)
+    v3 = empty(v, Float64)
+    @test !isempty(v)
+    empty!(v)
+    @test isempty(v)
+    @test isempty(v2::Vector{Int})
+    @test isempty(v3::Vector{Float64})
+end

test/dict.jl

@@ -433,11 +433,11 @@ end
 @testset "similar" begin
     d = Dict(:a=>2, :b=>3)
 
-    d2 = similar(d)
-    @test d2 isa typeof(d)
-    @test length(keys(d2)) == 2
-    @test :a ∈ keys(d2)
-    @test :b ∈ keys(d2)
+    # v1.0: d2 = similar(d)
+    # v1.0: @test d2 isa typeof(d)
+    # v1.0: @test length(keys(d2)) == 2
+    # v1.0: @test :a ∈ keys(d2)
+    # v1.0: @test :b ∈ keys(d2)
 
     d3 = similar(d, Float64)
     @test d3 isa Dict{Symbol, Float64}
@@ -458,6 +458,20 @@ end
     @test 10 ∈ keys(d5)
     @test 20 ∈ keys(d5)
     @test 30 ∈ keys(d5)
+
+    d6 = similar(d, (10, 20, 30))
+    @test d6 isa Dict{Int, Int}
+    @test length(keys(d6)) == 3
+    @test 10 ∈ keys(d6)
+    @test 20 ∈ keys(d6)
+    @test 30 ∈ keys(d6)
+
+    d7 = similar(d, Base.OneTo(3))
+    @test d7 isa Dict{Int, Int}
+    @test length(keys(d7)) == 3
+    @test 1 ∈ keys(d7)
+    @test 2 ∈ keys(d7)
+    @test 3 ∈ keys(d7)
 end
 
 @testset "generators, similar" begin

test/tuple.jl

@@ -83,6 +83,8 @@ end
         @test Tuple{Int,Vararg{Any}}.ninitialized == 1
         @test Tuple{Any,Any,Vararg{Any}}.ninitialized == 2
     end
+
+    @test empty((1, 2.0, "c")) === ()
 end
 
 @testset "size" begin