Deprecate dequeue!(::PriorityQueue[, key])

in favor of Base.popfirst!(pq) and Base.popat!(pq, key).

Author: jonas-schulze

src/DataStructures.jl

@@ -15,7 +15,7 @@ module DataStructures
     export complement, complement!
 
     export Deque, Stack, Queue, CircularDeque
-    export dequeue!, dequeue_pair!, update!
+    export dequeue_pair!, update!
     export capacity, num_blocks, top_with_handle, sizehint!
 
     export Accumulator, counter, reset!, inc!, dec!

src/deprecations.jl

@@ -12,3 +12,5 @@ Base.@deprecate_binding IntDisjointSets IntDisjointSet
 @deprecate enqueue!(q::PriorityQueue, x) Base.push!(q, x)
 @deprecate enqueue!(q::PriorityQueue, k, v) Base.push!(q, k=>v)
 @deprecate dequeue!(q::Queue) Base.popfirst!(q)
+@deprecate dequeue!(q::PriorityQueue) Base.popfirst!(q)
+@deprecate dequeue!(q::PriorityQueue, x) Base.popat!(q, x)

src/priorityqueue.jl

@@ -12,8 +12,8 @@ If an order is not given, the priority queue is min-ordered using
 the default comparison for `V`.
 
 A `PriorityQueue` acts like a `Dict`, mapping values to their
-priorities, with the addition of a `dequeue!` function to remove the
-lowest priority element.
+priorities. New elements are added using `push!` and retrieved
+using `popfirst!` or `popat!` based on their priority.
 
 ```jldoctest
 julia> PriorityQueue(Base.Order.Forward, "a" => 2, "b" => 3, "c" => 1)
@@ -242,7 +242,7 @@ end
 Base.push!(pq::PriorityQueue{K,V}, kv::Pair) where {K,V} = push!(pq, Pair{K,V}(kv.first, kv.second))
 
 """
-    dequeue!(pq)
+    popfirst!(pq)
 
 Remove and return the lowest priority key from a priority queue.
 
@@ -253,7 +253,7 @@ PriorityQueue{String, Int64, Base.Order.ForwardOrdering} with 3 entries:
   "a" => 2
   "b" => 3
 
-julia> dequeue!(a)
+julia> popfirst!(a)
 "c"
 
 julia> a
@@ -262,9 +262,9 @@ PriorityQueue{String, Int64, Base.Order.ForwardOrdering} with 2 entries:
   "b" => 3
 ```
 """
-dequeue!(pq::PriorityQueue) = dequeue_pair!(pq).first
+Base.popfirst!(pq::PriorityQueue) = dequeue_pair!(pq).first
 
-dequeue!(pq::PriorityQueue, key) = dequeue_pair!(pq, key).first
+Base.popat!(pq::PriorityQueue, key) = dequeue_pair!(pq, key).first
 
 """
     dequeue_pair!(pq)

test/test_priority_queue.jl

@@ -7,9 +7,9 @@ import Base.Order.Reverse
 
     # Test dequeing in sorted order.
     function test_issorted!(pq::PriorityQueue, priorities, rev=false)
-        last = dequeue!(pq)
+        last = popfirst!(pq)
         while !isempty(pq)
-            value = dequeue!(pq)
+            value = popfirst!(pq)
             if !rev
                 @test priorities[last] <= priorities[value]
             else
@@ -23,7 +23,7 @@ import Base.Order.Reverse
         i = 0
         while !isempty(pq)
             krqst =  keys[i+=1]
-            krcvd = dequeue!(pq, krqst)
+            krcvd = popat!(pq, krqst)
             @test krcvd == krqst
         end
     end
@@ -110,13 +110,13 @@ import Base.Order.Reverse
     @testset "PriorityQueueMethods" begin
         pq1 = PriorityQueue('a'=>1, 'b'=>2)
 
-        @testset "peek/get/dequeue!/get!" begin
+        @testset "peek/get/popfirst!/get!" begin
             @test peek(pq1) == ('a'=>1)
             @test get(pq1, 'a', 0) == 1
             @test get(pq1, 'c', 0) == 0
             @test get!(pq1, 'b', 20) == 2
-            @test dequeue!(pq1) == 'a'
-            @test dequeue!(pq1) == 'b'
+            @test popfirst!(pq1) == 'a'
+            @test popfirst!(pq1) == 'b'
             @test get!(pq1, 'c', 0) == 0
             @test peek(pq1) == ('c'=>0)
             @test get!(pq1, 'c', 3) == 0
@@ -190,15 +190,15 @@ import Base.Order.Reverse
 
         @testset "dequeuing" begin
             pq = PriorityQueue(priorities)
-            @test_throws KeyError dequeue!(pq, 0)
+            @test_throws KeyError popat!(pq, 0)
 
-            @test 10 == dequeue!(pq, 10)
+            @test 10 == popat!(pq, 10)
             while !isempty(pq)
-                @test 10 != dequeue!(pq)
+                @test 10 != popfirst!(pq)
             end
 
             pq = PriorityQueue(1.0 => 1)
-            @test dequeue!(pq, 1.0f0) isa Float64
+            @test popat!(pq, 1.0f0) isa Float64
         end
 
         @testset "dequeuing pair" begin