Update iterator protocol

Author: YingboMa

src/array_partition.jl

@@ -216,9 +216,8 @@ recursive_eltype(A::ArrayPartition) = recursive_eltype(first(A.x))
 
 ## iteration
 
-Base.start(A::ArrayPartition) = start(Chain(A.x))
-Base.next(A::ArrayPartition,state) = next(Chain(A.x),state)
-Base.done(A::ArrayPartition,state) = done(Chain(A.x),state)
+Base.iterate(A::ArrayPartition) = iterate(Chain(A.x))
+Base.iterate(A::ArrayPartition,state) = iterate(Chain(A.x),state)
 
 Base.length(A::ArrayPartition) = sum((length(x) for x in A.x))
 Base.size(A::ArrayPartition) = (length(A),)

src/utils.jl

@@ -145,30 +145,24 @@ Base.length(it::Chain) = sum(length, it.xss)
 
 Base.eltype(::Type{Chain{T}}) where {T} = typejoin([eltype(t) for t in T.parameters]...)
 
-function Base.start(it::Chain)
+function Base.iterate(it::Chain)
     i = 1
     xs_state = nothing
     while i <= length(it.xss)
-        xs_state = start(it.xss[i])
-        if !done(it.xss[i], xs_state)
-            break
-        end
+        xs_state = iterate(it.xss[i])
+        xs_state !== nothing && return xs_state[1], (i, xs_state[2])
         i += 1
     end
-    return i, xs_state
+    return nothing
 end
 
-function Base.next(it::Chain, state)
+function Base.iterate(it::Chain, state)
     i, xs_state = state
-    v, xs_state = next(it.xss[i], xs_state)
-    while done(it.xss[i], xs_state)
+    xs_state = iterate(it.xss[i], xs_state)
+    while xs_state == nothing
         i += 1
-        if i > length(it.xss)
-            break
-        end
-        xs_state = start(it.xss[i])
+        i > length(it.xss) && return nothing
+        xs_state = iterate(it.xss[i])
     end
-    return v, (i, xs_state)
+    return xs_state[1], (i, xs_state[2])
 end
-
-Base.done(it::Chain, state) = state[1] > length(it.xss)

src/vector_of_array.jl

@@ -23,7 +23,7 @@ DiffEqArray(vec::AbstractVector,ts::AbstractVector) = DiffEqArray(vec, ts, (size
 
 @inline Base.length(VA::AbstractVectorOfArray) = length(VA.u)
 @inline Base.eachindex(VA::AbstractVectorOfArray) = Base.OneTo(length(VA.u))
-@inline Base.iteratorsize(VA::AbstractVectorOfArray) = Base.HasLength()
+@inline Base.IteratorSize(VA::AbstractVectorOfArray) = Base.HasLength()
 # Linear indexing will be over the container elements, not the individual elements
 # unlike an true AbstractArray
 @inline Base.getindex(VA::AbstractVectorOfArray{T, N}, I::Int) where {T, N} = VA.u[I]

test/interface_tests.jl

@@ -54,7 +54,7 @@ testva2 = similar(testva)
 testval = 3.0
 fill!(testva2, testval)
 @test all(x->(x==testval), testva2)
-testts = rand(size(testva.u))
+testts = rand(Float64, size(testva.u))
 testda = DiffEqArray(recursivecopy(testva.u), testts)
 fill!(testda, testval)
 @test all(x->(x==testval), testda)