Deprecate reverse_iter to Iterators.reverse

Update src/deque.jl

Implement `last` for `Stack` and `reverse(::Stack)`

Bump patch version

Test `length` for `reverse`

Author: nickrobinson251

docs/src/stack_and_queue.md

@@ -1,4 +1,3 @@
-
 # Stack and Queue
 
 The `Stack` and `Queue` types are a light-weight wrapper of a deque
@@ -7,17 +6,17 @@ type, which respectively provide interfaces for LIFO and FIFO access.
 Usage of Stack:
 
 ```julia
-s = Stack{Int}()            # create a stack
-isempty(s)                  # check whether the stack is empty
-length(s)                   # get the number of elements
-eltype(s)                   # get the type of elements
-push!(s, 1)                 # push back a item
-first(s)                    # get an item from the top of stack
-pop!(s)                     # get and remove a first item
-empty!(s)                   # make a stack empty
-iterate(s::Stack)           # Get a LIFO iterator of a stack
-reverse_iter(s::Stack{T})   # Get a FILO iterator of a stack
-s1 == s2                    # check whether the two stacks are same
+s = Stack{Int}()                # create a stack
+isempty(s)                      # check whether the stack is empty
+length(s)                       # get the number of elements
+eltype(s)                       # get the type of elements
+push!(s, 1)                     # push back a item
+first(s)                        # get an item from the top of stack
+pop!(s)                         # get and remove a first item
+empty!(s)                       # make a stack empty
+iterate(s::Stack)               # Get a LIFO iterator of a stack
+Iterators.reverse(s::Stack{T})  # Get a FILO iterator of a stack
+s1 == s2                        # check whether the two stacks are same
 ```
 
 Usage of Queue:

src/DataStructures.jl

@@ -1,6 +1,6 @@
 module DataStructures
 
-    using Base: HasEltype, HasLength, IteratorEltype, IteratorSize, SizeUnknown,
+    using Base: Iterators, HasEltype, HasLength, IteratorEltype, IteratorSize, SizeUnknown,
                 lt, Ordering, ForwardOrdering, Forward, ReverseOrdering, Reverse, Lt,
                 isbitsunion, isiterable, dict_with_eltype, KeySet, Callable, _tablesz,
                 findnextnot, unsafe_getindex, unsafe_setindex!, peek
@@ -15,7 +15,7 @@ module DataStructures
     export complement, complement!
 
     export Deque, Stack, Queue, CircularDeque
-    export enqueue!, dequeue!, dequeue_pair!, update!, reverse_iter
+    export enqueue!, dequeue!, dequeue_pair!, update!
     export capacity, num_blocks, top_with_handle, sizehint!
 
     export Accumulator, counter, reset!, inc!, dec!

src/deprecations.jl

@@ -2,3 +2,4 @@
 @deprecate path(t::Trie, str::AbstractString) partial_path(t::Trie, str::AbstractString)
 @deprecate find_root find_root!
 @deprecate top first
+@deprecate reverse_iter Iterators.reverse

src/deque.jl

@@ -115,6 +115,8 @@ struct DequeIterator{T}
     q::Deque
 end
 
+Base.last(qi::DequeIterator) = last(qi.q)
+
 function Base.iterate(qi::DequeIterator{T}, (cb, i) = (qi.q.head, qi.q.head.front)) where T
     i > cb.back && return nothing
     x = cb.data[i]
@@ -130,11 +132,7 @@ end
 
 # Backwards deque iteration
 
-struct ReverseDequeIterator{T}
-    q::Deque
-end
-
-function Base.iterate(qi::ReverseDequeIterator{T}, (cb, i) = (qi.q.rear, qi.q.rear.back)) where T
+function Base.iterate(qi::Iterators.Reverse{<:Deque}, (cb, i) = (qi.itr.rear, qi.itr.rear.back))
     i < cb.front && return nothing
     x = cb.data[i]
 
@@ -148,12 +146,9 @@ function Base.iterate(qi::ReverseDequeIterator{T}, (cb, i) = (qi.q.rear, qi.q.re
     return (x, (cb, i))
 end
 
-reverse_iter(q::Deque{T}) where {T} = ReverseDequeIterator{T}(q)
-
 Base.iterate(q::Deque{T}, s...) where {T} = iterate(DequeIterator{T}(q), s...)
 
 Base.length(qi::DequeIterator{T}) where {T} = qi.q.len
-Base.length(qi::ReverseDequeIterator{T}) where {T} = qi.q.len
 
 Base.collect(q::Deque{T}) where {T} = T[x for x in q]
 

src/queue.jl

@@ -42,6 +42,6 @@ Base.empty!(s::Queue) = (empty!(s.store); s)
 
 Base.iterate(q::Queue, s...) = iterate(q.store, s...)
 
-reverse_iter(q::Queue) = reverse_iter(q.store)
+Iterators.reverse(q::Queue) = Iterators.reverse(q.store)
 
 Base.:(==)(x::Queue, y::Queue) = x.store == y.store

src/stack.jl

@@ -41,6 +41,7 @@ Base.eltype(::Type{Stack{T}}) where T = T
 Get the top item from the stack. Sometimes called peek.
 """
 Base.first(s::Stack) = last(s.store)
+Base.last(s::Stack) = first(s.store)
 
 function Base.push!(s::Stack, x)
     push!(s.store, x)
@@ -51,13 +52,8 @@ Base.pop!(s::Stack) = pop!(s.store)
 
 Base.empty!(s::Stack) = (empty!(s.store); s)
 
-Base.iterate(st::Stack, s...) = iterate(reverse_iter(st.store), s...)
+Base.iterate(st::Stack, s...) = iterate(Iterators.reverse(st.store), s...)
 
-"""
-    reverse_iterate(s::Stack)
-
-Get a FILO iterator of a stack
-"""
-reverse_iter(s::Stack{T}) where {T} = DequeIterator{T}(s.store)
+Iterators.reverse(s::Stack{T}) where {T} = DequeIterator{T}(s.store)
 
 Base.:(==)(x::Stack, y::Stack) = x.store == y.store

test/test_deprecations.jl

@@ -19,4 +19,25 @@ end
 @testset "top" begin
     hh = BinaryMinHeap{Float64}([1,2,3])
     @test top(hh) == 1
-end
+end
+
+function test_reverse_iter(it::T) where T
+    arr = [i for i in it]
+    index = length(arr)
+    for i in reverse_iter(it)
+        @test arr[index] == i
+        index -= 1
+    end
+
+    @test reverse(arr) == [i for i in reverse_iter(it)]
+end
+@testset "reverse_iter" begin
+    @testset "Queue" begin
+        q = Queue{Int}(); enqueue!(q, 1); enqueue!(q, 2)
+        test_reverse_iter(q)
+    end
+    @testset "Stack" begin
+        s = Stack{Int}(); push!(s, 1); push!(s, 2)
+        test_reverse_iter(s)
+    end
+end

test/test_queue.jl

@@ -93,14 +93,17 @@
 
         @testset "reverse iterator" begin
             index = length(arr)
-            for i in reverse_iter(q)
+            for i in Iterators.reverse(q)
                 @test(arr[index] == i)
                 index -= 1
             end
         end
 
         @test arr == [i for i in q]
-        @test reverse(arr) == [i for i in reverse_iter(q)]
+        @test reverse(arr) == [i for i in Iterators.reverse(q)]
+        @test first(Iterators.reverse(q)) === last(q)
+        @test last(Iterators.reverse(q)) === first(q)
+        @test length(Iterators.reverse(q)) === length(q)
     end
 
 end # @testset Queue

test/test_stack.jl

@@ -87,14 +87,17 @@
 
         @testset "reverse iterator" begin
             index = 1
-            for i in reverse_iter(stk)
+            for i in Iterators.reverse(stk)
                 @test(arr[index] == i)
                 index += 1
             end
         end
 
-        @test arr == [i for i in reverse_iter(stk)]
+        @test arr == [i for i in Iterators.reverse(stk)]
         @test reverse(arr) == [i for i in stk]
+        @test first(Iterators.reverse(stk)) === last(stk)
+        @test last(Iterators.reverse(stk)) === first(stk)
+        @test length(Iterators.reverse(stk)) === length(stk)
     end
 
 end # @testset Stack