more iterator trait declarations

Author: JeffBezanson

base/dict.jl

@@ -190,7 +190,9 @@ isempty(v::Union{KeyIterator,ValueIterator}) = isempty(v.dict)
 _tt1{A,B}(::Type{Pair{A,B}}) = A
 _tt2{A,B}(::Type{Pair{A,B}}) = B
 eltype{D}(::Type{KeyIterator{D}}) = _tt1(eltype(D))
+iteratoreltype{D}(::Type{KeyIterator{D}}) = HasEltype()
 eltype{D}(::Type{ValueIterator{D}}) = _tt2(eltype(D))
+iteratoreltype{D}(::Type{ValueIterator{D}}) = HasEltype()
 
 start(v::Union{KeyIterator,ValueIterator}) = start(v.dict)
 done(v::Union{KeyIterator,ValueIterator}, state) = done(v.dict, state)

base/generator.jl

@@ -54,5 +54,6 @@ size(g::Generator) = size(g.iter)
 
 iteratoreltype{T<:AbstractArray}(::Type{T}) = HasEltype()
 iteratoreltype{T<:AbstractString}(::Type{T}) = HasEltype()
+iteratoreltype{T<:Union{Number,Char}}(::Type{T}) = HasEltype()
 iteratoreltype{I,T}(::Type{Generator{I,Type{T}}}) = HasEltype()
 eltype{I,T}(::Type{Generator{I,Type{T}}}) = T

base/intset.jl

@@ -12,6 +12,7 @@ end
 IntSet(itr) = (s=IntSet(); for a in itr; push!(s,a); end; s)
 
 eltype(::Type{IntSet}) = Int64
+iteratoreltype(::Type{IntSet}) = HasEltype()
 similar(s::IntSet) = IntSet()
 
 function show(io::IO, s::IntSet)

base/io.jl

@@ -375,6 +375,7 @@ function done(itr::EachLine, nada)
 end
 next(itr::EachLine, nada) = (readline(itr.stream), nothing)
 eltype(::Type{EachLine}) = ByteString
+iteratoreltype(::Type{EachLine}) = HasEltype()
 
 readlines(s=STDIN) = collect(eachline(s))
 

base/multidimensional.jl

@@ -3,7 +3,7 @@
 ### Multidimensional iterators
 module IteratorsMD
 
-import Base: eltype, length, start, done, next, last, getindex, setindex!, linearindexing, min, max, eachindex, ndims
+import Base: eltype, length, size, start, done, next, last, getindex, setindex!, linearindexing, min, max, eachindex, ndims, iteratoreltype, iteratorsize
 importall ..Base.Operators
 import Base: simd_outer_range, simd_inner_length, simd_index, @generated
 import Base: @nref, @ncall, @nif, @nexprs, LinearFast, LinearSlow, to_index, AbstractCartesianIndex
@@ -103,6 +103,8 @@ end
 end
 
 eltype{I}(::Type{CartesianRange{I}}) = I
+iteratoreltype{I}(::Type{CartesianRange{I}}) = Base.HasEltype()
+iteratorsize{I}(::Type{CartesianRange{I}}) = Base.HasShape()
 
 @generated function start{I<:CartesianIndex}(iter::CartesianRange{I})
     N = length(I)
@@ -135,13 +137,15 @@ start{I<:CartesianIndex{0}}(iter::CartesianRange{I}) = false
 next{I<:CartesianIndex{0}}(iter::CartesianRange{I}, state) = iter.start, true
 done{I<:CartesianIndex{0}}(iter::CartesianRange{I}, state) = state
 
-@generated function length{I<:CartesianIndex}(iter::CartesianRange{I})
+@generated function size{I<:CartesianIndex}(iter::CartesianRange{I})
     N = length(I)
-    N == 0 && return 1
+    N == 0 && return ()
     args = [:(iter.stop[$i]-iter.start[$i]+1) for i=1:N]
-    Expr(:call,:*,args...)
+    Expr(:tuple,args...)
 end
 
+length(iter::CartesianRange) = prod(size(iter))
+
 last(iter::CartesianRange) = iter.stop
 
 @generated function simd_outer_range{I}(iter::CartesianRange{I})

base/regex.jl

@@ -325,6 +325,7 @@ immutable RegexMatchIterator
 end
 compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
 eltype(::Type{RegexMatchIterator}) = RegexMatch
+iteratoreltype(::Type{RegexMatchIterator}) = HasEltype()
 start(itr::RegexMatchIterator) = match(itr.regex, itr.string, 1, UInt32(0))
 done(itr::RegexMatchIterator, prev_match) = (prev_match === nothing)
 

base/set.jl

@@ -10,6 +10,7 @@ Set() = Set{Any}()
 Set(itr) = Set{eltype(itr)}(itr)
 
 eltype{T}(::Type{Set{T}}) = T
+iteratoreltype{T<:AbstractSet}(::Type{T}) = HasEltype()
 similar{T}(s::Set{T}) = Set{T}()
 
 function show(io::IO, s::Set)

base/strings/basic.jl

@@ -197,6 +197,8 @@ start(e::EachStringIndex) = start(e.s)
 next(e::EachStringIndex, state) = (state, nextind(e.s, state))
 done(e::EachStringIndex, state) = done(e.s, state)
 eltype(::Type{EachStringIndex}) = Int
+iteratoreltype(::Type{EachStringIndex}) = HasEltype()
+iteratorsize(::Type{EachStringIndex}) = HasLength()
 
 typealias Chars Union{Char,Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}
 

base/unicode/utf8proc.jl

@@ -3,7 +3,7 @@
 # Various Unicode functionality from the utf8proc library
 module UTF8proc
 
-import Base: show, ==, hash, string, symbol, isless, length, eltype, start, next, done, convert, isvalid, lowercase, uppercase
+import Base: show, ==, hash, string, symbol, isless, length, eltype, start, next, done, convert, isvalid, lowercase, uppercase, iteratoreltype, iteratorsize
 
 export isgraphemebreak
 
@@ -191,6 +191,8 @@ end
 graphemes(s::AbstractString) = GraphemeIterator{typeof(s)}(s)
 
 eltype{S}(::Type{GraphemeIterator{S}}) = SubString{S}
+iteratoreltype{S}(::Type{GraphemeIterator{S}}) = Base.HasEltype()
+iteratorsize{S}(::Type{GraphemeIterator{S}}) = Base.HasLength()
 
 function length(g::GraphemeIterator)
     c0 = Char(0x00ad) # soft hyphen (grapheme break always allowed after this)

test/simdloop.jl

@@ -104,17 +104,17 @@ end
 crng = CartesianRange(CartesianIndex{4}(2,0,1,3),
                       CartesianIndex{4}(4,1,1,5))
 indexes = simd_cartesian_range!(Array(eltype(crng), 0), crng)
-@test indexes == collect(crng)
+@test indexes == vec(collect(crng))
 
 crng = CartesianRange(CartesianIndex{2}(-1,1),
                       CartesianIndex{2}(1,3))
 indexes = simd_cartesian_range!(Array(eltype(crng), 0), crng)
-@test indexes == collect(crng)
+@test indexes == vec(collect(crng))
 
 crng = CartesianRange(CartesianIndex{2}(-1,1),
                       CartesianIndex{2}(-1,3))
 indexes = simd_cartesian_range!(Array(eltype(crng), 0), crng)
-@test indexes == collect(crng)
+@test indexes == vec(collect(crng))
 
 crng = CartesianRange(CartesianIndex{1}(2),
                       CartesianIndex{1}(4))
@@ -124,7 +124,7 @@ indexes = simd_cartesian_range!(Array(eltype(crng), 0), crng)
 crng = CartesianRange(CartesianIndex{0}(),
                       CartesianIndex{0}())
 indexes = simd_cartesian_range!(Array(eltype(crng), 0), crng)
-@test indexes == collect(crng)
+@test indexes == vec(collect(crng))
 
 # @simd with array as "range"
 # issue #13869