rename AbstractChunksIterator -> AbstractChunks

Author: carstenbauer

Diff for: src/internals.jl

@@ -7,15 +7,15 @@ abstract type Constraint end
 struct FixedCount <: Constraint end
 struct FixedSize <: Constraint end
 
-abstract type AbstractChunksIterator{T,C<:Constraint,S<:Split} end
+abstract type AbstractChunks{T,C<:Constraint,S<:Split} end
 
-struct ViewChunks{T,C<:Constraint,S<:Split} <: AbstractChunksIterator{T,C,S}
+struct ViewChunks{T,C<:Constraint,S<:Split} <: AbstractChunks{T,C,S}
     collection::T
     n::Int
     size::Int
 end
 
-struct IndexChunks{T,C<:Constraint,S<:Split} <: AbstractChunksIterator{T,C,S}
+struct IndexChunks{T,C<:Constraint,S<:Split} <: AbstractChunks{T,C,S}
     collection::T
     n::Int
     size::Int
@@ -61,7 +61,7 @@ end
 is_chunkable(::Any) = false
 is_chunkable(::AbstractArray) = true
 is_chunkable(::Tuple) = true
-is_chunkable(::AbstractChunksIterator) = true
+is_chunkable(::AbstractChunks) = true
 
 _set_minsize(minsize::Nothing) = 1
 function _set_minsize(minsize::Integer)
@@ -90,12 +90,12 @@ function err_not_chunkable(::T) where {T}
     throw(ArgumentError("Arguments of type $T are not compatible with chunks, either implement a custom chunks method for your type, or implement the custom type interface (see https://juliafolds2.github.io/ChunkSplitters.jl/dev/)"))
 end
 
-Base.firstindex(::AbstractChunksIterator) = 1
+Base.firstindex(::AbstractChunks) = 1
 
-Base.lastindex(c::AbstractChunksIterator) = length(c)
+Base.lastindex(c::AbstractChunks) = length(c)
 
-Base.length(c::AbstractChunksIterator{T,FixedCount,S}) where {T,S} = c.n
-Base.length(c::AbstractChunksIterator{T,FixedSize,S}) where {T,S} = cld(length(c.collection), max(1, c.size))
+Base.length(c::AbstractChunks{T,FixedCount,S}) where {T,S} = c.n
+Base.length(c::AbstractChunks{T,FixedSize,S}) where {T,S} = cld(length(c.collection), max(1, c.size))
 
 Base.getindex(c::IndexChunks{T,C,S}, i::Int) where {T,C,S} = getchunkindices(c, i)
 Base.getindex(c::ViewChunks{T,C,S}, i::Int) where {T,C,S} = @view(c.collection[getchunkindices(c, i)])
@@ -105,7 +105,7 @@ Base.eltype(::IndexChunks{T,C,RoundRobin}) where {T,C} = StepRange{Int,Int}
 Base.eltype(c::ViewChunks{T,C,Consecutive}) where {T,C} = typeof(c[firstindex(c)])
 Base.eltype(c::ViewChunks{T,C,RoundRobin}) where {T,C} = typeof(c[firstindex(c)])
 
-function Base.iterate(c::AbstractChunksIterator, state=firstindex(c))
+function Base.iterate(c::AbstractChunks, state=firstindex(c))
     if state > lastindex(c)
         return nothing
     else
@@ -117,42 +117,42 @@ end
 # with `@threads` and co, because of the lack of the general definition of
 # `firstindex`, `lastindex`, and `getindex` for `Base.Iterators.Enumerate{<:Any}`. Thus,
 # to avoid using the internal `.itr` property of `Enumerate`, we redefine
-# the `iterate` method for `ChunkSplitters.Enumerate{<:AbstractChunksIterator}`.
-struct Enumerate{I<:AbstractChunksIterator}
+# the `iterate` method for `ChunkSplitters.Enumerate{<:AbstractChunks}`.
+struct Enumerate{I<:AbstractChunks}
     itr::I
 end
-Base.enumerate(c::AbstractChunksIterator) = Enumerate(c)
+Base.enumerate(c::AbstractChunks) = Enumerate(c)
 
-function Base.iterate(ec::Enumerate{<:AbstractChunksIterator}, state=firstindex(ec.itr))
+function Base.iterate(ec::Enumerate{<:AbstractChunks}, state=firstindex(ec.itr))
     if state > lastindex(ec.itr)
         return nothing
     else
         return ((state, @inbounds(ec.itr[state])), state + 1)
     end
 end
 
-Base.eltype(ec::Enumerate{<:AbstractChunksIterator{T,C,Consecutive}}) where {T,C} = Tuple{Int,eltype(ec.itr)}
-Base.eltype(ec::Enumerate{<:AbstractChunksIterator{T,C,RoundRobin}}) where {T,C} = Tuple{Int,eltype(ec.itr)}
+Base.eltype(ec::Enumerate{<:AbstractChunks{T,C,Consecutive}}) where {T,C} = Tuple{Int,eltype(ec.itr)}
+Base.eltype(ec::Enumerate{<:AbstractChunks{T,C,RoundRobin}}) where {T,C} = Tuple{Int,eltype(ec.itr)}
 
-Base.firstindex(::Enumerate{<:AbstractChunksIterator}) = 1
+Base.firstindex(::Enumerate{<:AbstractChunks}) = 1
 
-Base.lastindex(ec::Enumerate{<:AbstractChunksIterator}) = lastindex(ec.itr)
+Base.lastindex(ec::Enumerate{<:AbstractChunks}) = lastindex(ec.itr)
 
-Base.getindex(ec::Enumerate{<:AbstractChunksIterator}, i::Int) = (i, ec.itr[i])
+Base.getindex(ec::Enumerate{<:AbstractChunks}, i::Int) = (i, ec.itr[i])
 
-Base.length(ec::Enumerate{<:AbstractChunksIterator}) = length(ec.itr)
+Base.length(ec::Enumerate{<:AbstractChunks}) = length(ec.itr)
 
-Base.eachindex(ec::Enumerate{<:AbstractChunksIterator}) = Base.OneTo(length(ec.itr))
+Base.eachindex(ec::Enumerate{<:AbstractChunks}) = Base.OneTo(length(ec.itr))
 
 _empty_itr(::Type{Consecutive}) = 0:-1
 _empty_itr(::Type{RoundRobin}) = 0:1:-1
 
 """
-    getchunkindices(c::AbstractChunksIterator, i::Integer)
+    getchunkindices(c::AbstractChunks, i::Integer)
 
 Returns the range of indices of `collection` that corresponds to the `i`-th chunk.
 """
-function getchunkindices(c::AbstractChunksIterator{T,C,S}, ichunk::Integer) where {T,C,S}
+function getchunkindices(c::AbstractChunks{T,C,S}, ichunk::Integer) where {T,C,S}
     length(c) == 0 && return _empty_itr(S)
     ichunk <= length(c.collection) || throw(ArgumentError("ichunk must be less or equal to the length of the ChunksIterator"))
     if C == FixedCount