update to Julia 1

Author: rfourquet

src/Primes.jl

@@ -4,7 +4,7 @@ module Primes
 
 using Base.Iterators: repeated
 
-import Base: start, next, done, eltype, iteratorsize, iteratoreltype
+import Base: iterate, eltype, IteratorSize, IteratorEltype
 using Base: BitSigned
 using Base.Checked: checked_neg
 
@@ -675,36 +675,38 @@ struct NextPrimes{T<:Integer}
     start::T
 end
 
-Base.start(np::NextPrimes) = np.start < 2 ? np.start : add(np.start, -1)
-Base.next(np::NextPrimes, state) = (p = nextprime(add(state, 1)); (p, p))
-Base.done(np::NextPrimes, state) = false
+function iterate(np::NextPrimes,
+                 state = p = np.start < 2 ? np.start : add(np.start, -1)
+                 )
+    p = nextprime(add(state, 1))
+    (p, p)
+end
 
-Base.iteratorsize(::Type{<:NextPrimes}) = Base.IsInfinite()
-Base.iteratoreltype(::Type{<:NextPrimes}) = Base.HasEltype() # default
+IteratorSize(::Type{<:NextPrimes}) = Base.IsInfinite()
+IteratorEltype(::Type{<:NextPrimes}) = Base.HasEltype()
 
-Base.eltype(::Type{NextPrimes{T}}) where {T} = T
+eltype(::Type{NextPrimes{T}}) where {T} = T
 
 """
     nextprimes(start::Integer)
 
-Returns an iterator over all primes greater than or equal to `start`,
+Return an iterator over all primes greater than or equal to `start`,
 in ascending order.
 """
 nextprimes(start::Integer) = NextPrimes(start)
 
 """
     nextprimes(T::Type=Int)
 
-Returns an iterator over all primes, with type `T`.
+Return an iterator over all primes, with type `T`.
 Equivalent to `nextprimes(T(1))`.
 """
-nextprimes(::Type{T}) where {T<:Integer} = nextprimes(one(T))
-nextprimes() = nextprimes(Int)
+nextprimes(::Type{T}=Int) where {T<:Integer} = nextprimes(one(T))
 
 """
     nextprimes(start::Integer, n::Integer)
 
-Returns an array of the first `n` primes greater than or equal to `start`.
+Return an array of the first `n` primes greater than or equal to `start`.
 
 # Example
 
@@ -716,25 +718,34 @@ julia> nextprimes(10, 3)
  17
 ```
 """
-nextprimes(start::T, n::Integer) where {T<:Integer} = collect(T, take(nextprimes(start), n))
+nextprimes(start::T, n::Integer) where {T<:Integer} =
+    collect(T, Iterators.take(nextprimes(start), n))
 
 struct PrevPrimes{T<:Integer}
     start::T
 end
 
-start(np::PrevPrimes) = np.start+one(np.start) # allow wrap-around
-next(np::PrevPrimes, state) = (p = prevprime(state-one(state)); (p, p))
-done(np::PrevPrimes, state) = state == 2
+function iterate(np::PrevPrimes,
+                 state = np.start+one(np.start) # allow wrap-around
+                 )
+    c = state-one(state)
+    if isone(c)
+        nothing
+    else
+        p = prevprime(c)
+        (p, p)
+    end
+end
 
-iteratorsize(::Type{<:PrevPrimes}) = Base.SizeUnknown()
-iteratoreltype(::Type{<:PrevPrimes}) = Base.HasEltype() # default
+IteratorSize(::Type{<:PrevPrimes}) = Base.SizeUnknown()
+Iteratoreltype(::Type{<:PrevPrimes}) = Base.HasEltype()
 
 eltype(::Type{PrevPrimes{T}}) where {T} = T
 
 """
     prevprimes(start::Integer)
 
-Returns an iterator over all primes less than or equal to `start`,
+Return an iterator over all primes less than or equal to `start`,
 in descending order.
 
 # Example
@@ -753,8 +764,9 @@ prevprimes(start::Integer) = PrevPrimes(max(one(start), start))
 """
     prevprimes(start::Integer, n::Integer)
 
-Returns an array of the first `n` primes less than or equal to `start`,
-in descending order.
+Return an array of the first `n` primes less than or equal to `start`,
+in descending order. When there are less than `n` primes less than or
+equal to `start`, those primes are returned without an error.
 
 # Example
 
@@ -764,8 +776,16 @@ julia> prevprimes(10, 3)
  7
  5
  3
+
+julia> prevprimes(10, 10)
+3-element Array{Int64,1}:
+ 7
+ 5
+ 3
+ 2
 ```
 """
-prevprimes(start::T, n::Integer) where {T<:Integer} = collect(T, take(prevprimes(start, n)))
+prevprimes(start::T, n::Integer) where {T<:Integer} =
+    collect(T, Iterators.take(prevprimes(start), n))
 
 end # module

test/runtests.jl

@@ -417,7 +417,6 @@ end
     @test prevprimes(6, 1)[1] == prevprimes(5, 1)[1] == 5
     @test prevprimes(4, 1)[1] == prevprimes(3, 1)[1] == 3
     @test prevprimes(2, 1)[1] == 2
-    @test_throws ArgumentError prevprimes(2, 2)
     let p8 = collect(prevprimes(typemax(Int8)))
         @test length(p8) == 31
         @test p8[end] == 2