Merge pull request #643 from JuliaCollections/ox/break

oxinabox · web-flow · commit 64cc58956c7c · 2020-08-04T19:38:15.000+01:00
Mark as 0.18-DEV and remove deprecations
diff --git a/Project.toml b/Project.toml
@@ -1,6 +1,6 @@
 name = "DataStructures"
 uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
-version = "0.17.20"
+version = "0.18.0-DEV"
 
 [deps]
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
diff --git a/docs/src/heaps.md b/docs/src/heaps.md
@@ -15,9 +15,9 @@ isempty(h)        # returns whether the heap is empty
 
 push!(h, v)       # add a value to the heap
 
-top(h)            # return the top value of a heap
+first(h)            # return the first (top) value of a heap
 
-pop!(h)           # removes the top value, and returns it
+pop!(h)           # removes the first (top) value, and returns it
 
 ```
 
@@ -73,7 +73,7 @@ popmax!(h, k)  # remove and return the largest k elements
 popall!(h)     # remove and return all the elements, sorted smallest to largest
 popall!(h, o)  # remove and return all the elements according to ordering o
 ```
-The usual `top(h)` and `pop!(h)` are defined to be `minimum(h)` and `popmin!(h)`,
+The usual `first(h)` and `pop!(h)` are defined to be `minimum(h)` and `popmin!(h)`,
 respectively.
 
 This package includes an implementation of a binary min-max heap (`BinaryMinMaxHeap`).
diff --git a/src/DataStructures.jl b/src/DataStructures.jl
@@ -27,12 +27,7 @@ module DataStructures
     export capacity, num_blocks, top_with_handle, sizehint!
 
     export Accumulator, counter, reset!, inc!, dec!
-
-    export ClassifiedCollections
-    export classified_lists, classified_sets, classified_counters
-
     export IntDisjointSets, DisjointSets, num_groups, find_root!, in_same_set, root_union!
-
     export FenwickTree, length, inc!, dec!, incdec!, prefixsum
 
     export AbstractHeap, compare, extract_all!
@@ -70,7 +65,6 @@ module DataStructures
     include("stack.jl")
     include("queue.jl")
     include("accumulator.jl")
-    include("classified_collections.jl")
     include("disjoint_set.jl")
     include("heaps.jl")
 
diff --git a/src/classified_collections.jl b/src/classified_collections.jl
diff --git a/src/default_dict.jl b/src/default_dict.jl
@@ -59,7 +59,6 @@ DefaultDictBase{K,V}(default::F; kwargs...) where {K,V,F} = DefaultDictBase{K,V,
 @delegate_return_parent DefaultDictBase.d [ delete!, empty!, setindex!, sizehint! ]
 
 empty(d::DefaultDictBase{K,V,F}) where {K,V,F} = DefaultDictBase{K,V,F}(d.default; passkey=d.passkey)
-@deprecate similar(d::DefaultDictBase) empty(d)
 
 getindex(d::DefaultDictBase, key) = get!(d.d, key, d.default)
 
@@ -144,8 +143,6 @@ for _Dict in [:Dict, :OrderedDict]
 
         empty(d::$DefaultDict{K,V,F}) where {K,V,F} = $DefaultDict{K,V,F}(d.d.default)
         in(key, v::Base.KeySet{K,T}) where {K,T<:$DefaultDict{K}} = key in keys(v.dict.d.d)
-
-        @deprecate similar(d::$DefaultDict) empty(d)
     end
 end
 
diff --git a/src/deprecations.jl b/src/deprecations.jl
@@ -1,10 +1,3 @@
-@deprecate front(x) first(x)
-@deprecate back(x) last(x)
-@deprecate top(x) first(x)
-#@deprecate find_root find_root! # 2020-03-31 - deprecate in v0.18, or when Julia 1.5 is released.
-export find_root
-const find_root = find_root!
-
-@deprecate deque(::Type{T}) where {T} Deque{T}()
-
-@deprecate path(t::Trie, str::AbstractString) partial_path(t::Trie, str::AbstractString)
+# 0.18 deprecations. Remove before releasing 0.19
+@deprecate path(t::Trie, str::AbstractString) partial_path(t::Trie, str::AbstractString)
+@deprecate find_root find_root!
diff --git a/src/heaps.jl b/src/heaps.jl
@@ -24,9 +24,9 @@
 #
 #   - sizehint!(h, s)     set size hint to a heap
 #
-#   - top(h)              return the top value of a heap
+#   - first(h)              return the first (top) value of a heap
 #
-#   - pop!(h)             removes the top value, and
+#   - pop!(h)             removes the first (top) value, and
 #                         returns it
 #
 #  For mutable heaps, it should also support
@@ -113,7 +113,7 @@ function nextreme(comp::Comp, n::Int, arr::AbstractVector{T}) where {T, Comp}
 
     for i = n + 1 : length(arr)
         @inbounds xi = arr[i]
-        if compare(comp, top(buffer), xi)
+        if compare(comp, first(buffer), xi)
             # This could use a pushpop method
             pop!(buffer)
             push!(buffer, xi)
diff --git a/src/heaps/binary_heap.jl b/src/heaps/binary_heap.jl
@@ -144,10 +144,10 @@ function sizehint!(h::BinaryHeap, s::Integer)
 end
 
 """
-    top(h::BinaryHeap)
+    first(h::BinaryHeap)
 
 Returns the element at the top of the heap `h`.
 """
-@inline top(h::BinaryHeap) = h.valtree[1]
+@inline first(h::BinaryHeap) = h.valtree[1]
 
 pop!(h::BinaryHeap{T}) where {T} = _binary_heap_pop!(h.comparer, h.valtree)
diff --git a/src/heaps/minmax_heap.jl b/src/heaps/minmax_heap.jl
@@ -244,11 +244,11 @@ function push!(h::BinaryMinMaxHeap, v)
 end
 
 """
-    top(h::BinaryMinMaxHeap)
+    first(h::BinaryMinMaxHeap)
 
-Get the top (minimum) of the heap.
+Get the first (minimum) of the heap.
 """
-@inline top(h::BinaryMinMaxHeap) = minimum(h)
+@inline first(h::BinaryMinMaxHeap) = minimum(h)
 
 @inline function minimum(h::BinaryMinMaxHeap)
     valtree = h.valtree
diff --git a/src/heaps/mutable_binary_heap.jl b/src/heaps/mutable_binary_heap.jl
@@ -178,14 +178,6 @@ const MutableBinaryMaxHeap{T} = MutableBinaryHeap{T, GreaterThan}
 MutableBinaryMinHeap(xs::AbstractVector{T}) where T = MutableBinaryMinHeap{T}(xs)
 MutableBinaryMaxHeap(xs::AbstractVector{T}) where T = MutableBinaryMaxHeap{T}(xs)
 
-# deprecated constructors
-
-@deprecate mutable_binary_minheap(::Type{T}) where {T} MutableBinaryMinHeap{T}()
-@deprecate mutable_binary_minheap(xs::AbstractVector{T}) where {T} MutableBinaryMinHeap(xs)
-@deprecate mutable_binary_maxheap(::Type{T}) where {T} MutableBinaryMaxHeap{T}()
-@deprecate mutable_binary_maxheap(xs::AbstractVector{T}) where {T} MutableBinaryMaxHeap(xs)
-
-
 function show(io::IO, h::MutableBinaryHeap)
     print(io, "MutableBinaryHeap(")
     nodes = h.nodes
@@ -227,7 +219,7 @@ function sizehint!(h::MutableBinaryHeap, s::Integer)
     return h
 end
 
-@inline top(h::MutableBinaryHeap) = h.nodes[1].value
+@inline first(h::MutableBinaryHeap) = h.nodes[1].value
 
 """
     top_with_handle(h::MutableBinaryHeap)
diff --git a/src/multi_dict.jl b/src/multi_dict.jl
@@ -52,8 +52,6 @@ empty(d::MultiDict{K,V}) where {K,V} = MultiDict{K,V}()
 delete!(d::MultiDict, key) = (delete!(d.d, key); d)
 empty!(d::MultiDict) = (empty!(d.d); d)
 
-@deprecate similar(d::MultiDict) empty(d)
-
 function insert!(d::MultiDict{K,V}, k, v) where {K,V}
     if !haskey(d.d, k)
         d.d[k] = V[]
diff --git a/src/sorted_dict.jl b/src/sorted_dict.jl
@@ -623,6 +623,4 @@ empty). Time: O(1)
 empty(m::SortedDict{K,D,Ord}) where {K,D,Ord<:Ordering} =
     SortedDict{K,D,Ord}(orderobject(m))
 
-@deprecate similar(m::SortedDict) empty(m)
-
 isordered(::Type{T}) where {T<:SortedDict} = true
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -16,7 +16,6 @@ tests = ["deprecations",
          "stack",
          "queue",
          "accumulator",
-         "classified_collections",
          "disjoint_set",
          "binheap",
          "mutable_binheap",
diff --git a/test/test_binheap.jl b/test/test_binheap.jl
@@ -10,7 +10,7 @@
 
             @test length(h) == 10
             @test !isempty(h)
-            @test top(h) == 1
+            @test first(h) == 1
             @test isequal(h.valtree, [1, 2, 3, 4, 7, 9, 10, 14, 8, 16])
             @test sizehint!(h, 100) === h
         end
@@ -20,7 +20,7 @@
 
             @test length(h) == 10
             @test !isempty(h)
-            @test top(h) == 16
+            @test first(h) == 16
             @test isequal(h.valtree, [16, 14, 10, 8, 7, 3, 9, 1, 4, 2])
             @test sizehint!(h, 100) === h
         end
diff --git a/test/test_classified_collections.jl b/test/test_classified_collections.jl
diff --git a/test/test_deque.jl b/test/test_deque.jl
@@ -197,9 +197,4 @@
         @test typeof(empty!(q)) === typeof(Deque{Int}())
         @test isempty(q)
     end
-
-    @testset "deprecated constructors" begin
-        @test_deprecated deque(Int)
-    end
-
 end # @testset Deque
diff --git a/test/test_minmax_heap.jl b/test/test_minmax_heap.jl
@@ -28,7 +28,7 @@ using Base.Order: Forward, Reverse
             h = BinaryMinMaxHeap(vs)
             @test length(h) == 10
             @test !isempty(h)
-            @test top(h) == minimum(h) == 1
+            @test first(h) == minimum(h) == 1
             @test maximum(h) == 20
             @test is_minmax_heap(h.valtree)
         end
@@ -48,7 +48,7 @@ using Base.Order: Forward, Reverse
             @test isempty(h)
 
             push!(h, 1)
-            @test top(h) == 1
+            @test first(h) == 1
             push!(h, 2)
             @test is_minmax_heap(h.valtree)
             push!(h, 10)
@@ -163,10 +163,8 @@ using Base.Order: Forward, Reverse
         h = BinaryMinMaxHeap{Int}()
         @test_throws ArgumentError pop!(h)
         @test_throws ArgumentError popmin!(h)
-
         @test_throws ArgumentError popmax!(h)
 
-        @test_throws ArgumentError top(h)
         @test_throws ArgumentError minimum(h)
         @test_throws ArgumentError maximum(h)
 
diff --git a/test/test_mutable_binheap.jl b/test/test_mutable_binheap.jl

Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,9 @@`
`24`	`24`	`#`
`25`	`25`	`# - sizehint!(h, s) set size hint to a heap`
`26`	`26`	`#`
`27`		`-# - top(h) return the top value of a heap`
	`27`	`+# - first(h) return the first (top) value of a heap`
`28`	`28`	`#`
`29`		`-# - pop!(h) removes the top value, and`
	`29`	`+# - pop!(h) removes the first (top) value, and`
`30`	`30`	`# returns it`
`31`	`31`	`#`
`32`	`32`	`# For mutable heaps, it should also support`
`@@ -113,7 +113,7 @@ function nextreme(comp::Comp, n::Int, arr::AbstractVector{T}) where {T, Comp}`
`113`	`113`
`114`	`114`	`for i = n + 1 : length(arr)`
`115`	`115`	`@inbounds xi = arr[i]`
`116`		`- if compare(comp, top(buffer), xi)`
	`116`	`+ if compare(comp, first(buffer), xi)`
`117`	`117`	`# This could use a pushpop method`
`118`	`118`	`pop!(buffer)`
`119`	`119`	`push!(buffer, xi)`