change similar(::AbstractSet) to empty(::AbstractSet)

base/array.jl

@@ -583,7 +583,7 @@ function collect_to!(dest::AbstractArray{T}, itr, offs, st) where T
 end
 
 function grow_to!(dest, itr)
- out = grow_to!(similar(dest,Union{}), itr, start(itr))
+ out = grow_to!(empty(dest, Union{}), itr, start(itr))
  return isempty(out) ? dest : out
 end
 
@@ -595,12 +595,12 @@ function grow_to!(dest, itr, st)
  if S === T || S <: T
  push!(dest, el::T)
  else
- new = similar(dest, typejoin(T, S))
+ new = sizehint!(empty(dest, typejoin(T, S)), length(dest))
  if new isa AbstractSet
- # TODO: merge back these two branches when copy! is re-enabled for sets
+ # TODO: merge back these two branches when copy! is re-enabled for sets/vectors
  union!(new, dest)
  else
- copyto!(new, dest)
+ append!(new, dest)
  end
  push!(new, el)
  return grow_to!(new, itr, st)
@@ -2214,7 +2214,7 @@ function filter!(f, a::AbstractVector)
  return a
 end
 
-filter(f, a::Vector) = mapfilter(f, push!, a, similar(a, 0))
+filter(f, a::Vector) = mapfilter(f, push!, a, empty(a))
 
 # set-like operators for vectors
 # These are moderately efficient, preserve order, and remove dupes.

base/bitset.jl

@@ -31,7 +31,6 @@ BitSet(itr) = union!(BitSet(), itr)
 @inline intoffset(s::BitSet) = s.offset << 6
 
 eltype(::Type{BitSet}) = Int
-similar(s::BitSet) = BitSet()
 
 empty(s::BitSet, ::Type{Int}=Int) = BitSet()
 emptymutable(s::BitSet, ::Type{Int}=Int) = BitSet()

base/deprecated.jl

@@ -3363,6 +3363,10 @@ info(err::Exception; prefix="ERROR: ", kw...) =
 @deprecate similar(a::AbstractDict) empty(a)
 @deprecate similar(a::AbstractDict, ::Type{Pair{K,V}}) where {K, V} empty(a, K, V)
 
+# 25224
+@deprecate similar(s::AbstractSet) empty(s)
+@deprecate similar(s::AbstractSet, ::Type{T}) where {T} empty(s, T)
+
 # PR #24594
 @eval LibGit2 begin
  @deprecate AbstractCredentials AbstractCredential false

base/set.jl

@@ -27,14 +27,14 @@ function Set(g::Generator)
  return Set{T}(g)
 end
 
-similar(s::Set{T}, ::Type{U}=T) where {T,U} = Set{U}()
-
 empty(s::Set{T}, ::Type{U}=T) where {T,U} = Set{U}()
 
 # return an empty set with eltype T, which is mutable (can be grown)
 # by default, a Set is returned
 emptymutable(s::AbstractSet{T}, ::Type{U}=T) where {T,U} = Set{U}()
 
+_similar_for(c::AbstractSet, T, itr, isz) = empty(c, T)
+
 function show(io::IO, s::Set)
  print(io, "Set(")
  show_vector(io, s)
@@ -519,7 +519,7 @@ allunique(::Set) = true
 
 allunique(r::AbstractRange{T}) where {T} = (step(r) != zero(T)) || (length(r) <= 1)
 
-filter(pred, s::AbstractSet) = mapfilter(pred, push!, s, similar(s))
+filter(pred, s::AbstractSet) = mapfilter(pred, push!, s, emptymutable(s))
 filter!(f, s::Set) = unsafe_filter!(f, s)
 
 # it must be safe to delete the current element while iterating over s:

test/bitset.jl

@@ -10,10 +10,10 @@
  @test length(data_out) === length(data_in)
 end
 
-@testset "eltype, similar" begin
+@testset "eltype, empty" begin
  @test eltype(BitSet()) === Int
  @test eltype(BitSet) === Int
- @test isequal(similar(BitSet([1,2,3])), BitSet())
+ @test isequal(empty(BitSet([1,2,3])), BitSet())
 end
 
 @testset "show" begin
@@ -99,9 +99,9 @@ end
  @test_throws MethodError symdiff!(BitSet([1, 2]), [[1]]) # should not return BitSet([2])
 end
 
-@testset "copy, copy!, similar" begin
+@testset "copy, copy!, empty" begin
  s1 = BitSet([1,2,3])
- s2 = similar(s1)
+ s2 = empty(s1)
  copy!(s2, s1)
  s3 = copy(s2)
  @test s3 == s2 == s1

test/sets.jl

@@ -61,14 +61,14 @@ end
  @test !isequal(Set{Any}([1,2,3,4]), Set{Int}([1,2,3]))
  @test !isequal(Set{Int}([1,2,3,4]), Set{Any}([1,2,3]))
 end
-@testset "eltype, similar" begin
- s1 = similar(Set([1,"hello"]))
+@testset "eltype, empty" begin
+ s1 = empty(Set([1,"hello"]))
  @test isequal(s1, Set())
  @test ===(eltype(s1), Any)
- s2 = similar(Set{Float32}([2.0f0,3.0f0,4.0f0]))
+ s2 = empty(Set{Float32}([2.0f0,3.0f0,4.0f0]))
  @test isequal(s2, Set())
  @test ===(eltype(s2), Float32)
- s3 = similar(Set([1,"hello"]),Float32)
+ s3 = empty(Set([1,"hello"]),Float32)
  @test isequal(s3, Set())
  @test ===(eltype(s3), Float32)
 end