findfirst and findnext for general iterables

base/abstractarray.jl

@@ -1009,6 +1009,8 @@ sub2ind(dims::Tuple{Vararg{Integer}}, I::Integer...) = _sub2ind(dims,I)
     end
     Expr(:block, meta,:($ex + 1))
 end
+sub2ind(A::AbstractArray, I::Integer...) = _sub2ind(size(A), I)
+_sub2ind(A::AbstractArray, I) = _sub2ind(size(A), I)
 
 @generated function ind2sub{N}(dims::NTuple{N,Integer}, ind::Integer)
     meta = Expr(:meta,:inline)

base/array.jl

@@ -727,15 +727,19 @@ end
 findfirst(A) = findnext(A, 1)
 
 # returns the index of the next matching element
-function findnext(A, v, start::Integer)
-    for i = start:length(A)
-        if A[i] == v
-            return i
+function findnext{T}(iter, v, state::T, failed::T)
+    while !done(iter, state)
+        oldstate = state
+        item, state = next(iter, state)
+        if item == v
+            return oldstate
         end
     end
-    return 0
+    return failed
 end
-findfirst(A, v) = findnext(A, v, 1)
+findnext(iter, v, state::Integer) = findnext(iter, v, state, oftype(state, 0))
+
+findfirst(iter, v) = findnext(iter, v, start(iter))
 
 # returns the index of the next element for which the function returns true
 function findnext(testf::Function, A, start::Integer)

base/bitarray.jl

@@ -1295,7 +1295,7 @@ function findnext(B::BitArray, start::Integer)
     end
     return 0
 end
-#findfirst(B::BitArray) = findnext(B, 1)  ## defined in array.jl
+findfirst(B::BitArray) = findnext(B, 1)
 
 # aux function: same as findnext(~B, start), but performed without temporaries
 function findnextnot(B::BitArray, start::Integer)
@@ -1335,7 +1335,7 @@ function findnext(B::BitArray, v, start::Integer)
     v == true && return findnext(B, start)
     return 0
 end
-#findfirst(B::BitArray, v) = findnext(B, 1, v)  ## defined in array.jl
+findfirst(B::BitArray, v) = findnext(B, v, 1)
 
 # returns the index of the first element for which the function returns true
 function findnext(testf::Function, B::BitArray, start::Integer)

base/deprecated.jl

@@ -368,7 +368,6 @@ end
 @deprecate flipud(A::AbstractArray) flipdim(A, 1)
 @deprecate fliplr(A::AbstractArray) flipdim(A, 2)
 
-@deprecate sub2ind{T<:Integer}(dims::Array{T}, sub::Array{T}) sub2ind(tuple(dims...), sub...)
 @deprecate ind2sub!{T<:Integer}(sub::Array{T}, dims::Array{T}, ind::T) ind2sub!(sub, tuple(dims...), ind)
 
 @deprecate strftime     Libc.strftime

base/multidimensional.jl

@@ -3,7 +3,7 @@
 ### Multidimensional iterators
 module IteratorsMD
 
-import Base: eltype, length, size, start, done, next, last, getindex, setindex!, linearindexing, min, max, eachindex, ndims, iteratorsize
+import Base: eltype, length, size, start, done, next, last, getindex, setindex!, linearindexing, min, max, eachindex, ndims, iteratorsize, sub2ind, _sub2ind
 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
@@ -50,6 +50,10 @@ length{N}(::Type{CartesianIndex{N}})=N
 # indexing
 getindex(index::CartesianIndex, i::Integer) = index.I[i]
 
+# conversion to linear index
+sub2ind(A::AbstractArray, I::CartesianIndex) = _sub2ind(A, I.I)
+_sub2ind(A::AbstractArray, I::CartesianIndex) = _sub2ind(A, I.I)
+
 # arithmetic, min/max
 for op in (:+, :-, :min, :max)
     @eval begin

base/nullable.jl

@@ -62,3 +62,28 @@ function hash(x::Nullable, h::UInt)
         return hash(x.value, h + nullablehash_seed)
     end
 end
+
+## Methods that can't be defined until we have Nullable
+
+function findnext{T}(iter, v, state::T, failed::Nullable{T})
+    while !done(iter, state)
+        oldstate = state
+        item, state = next(iter, state)
+        if item == v
+            return Nullable(oldstate)
+        end
+    end
+    return failed
+end
+
+findnext(iter, v, state) = findnext(iter, v, state, Nullable{typeof(state)}())
+
+# For arrays, ensure findfirst returns an integer even for LinearSlow
+_findnext(A::AbstractArray, v, state::Integer) = findnext(A, v, state, oftype(state, 0))
+function _findnext(A::AbstractArray, v, state)
+    found = findnext(A, v, state)
+    isnull(found) && return 0
+    sub2ind(A, get(found)[2])
+end
+
+findfirst(A::AbstractArray, v) = _findnext(A, v, start(A))

test/arrayops.jl

@@ -285,6 +285,7 @@ a = [0,1,2,3,0,1,2,3]
 @test findnext(a,1) == 2
 @test findnext(a,1,4) == 6
 @test findnext(a,5,4) == 0
+@test findnext(a,5,0x04) === 0x00
 @test findlast(a) == 8
 @test findlast(a.==0) == 5
 @test findlast(a.==5) == 0
@@ -298,6 +299,13 @@ a = [0,1,2,3,0,1,2,3]
 @test findprev(a,1,8) == 6
 @test findprev(isodd, [2,4,5,3,9,2,0], 7) == 5
 @test findprev(isodd, [2,4,5,3,9,2,0], 2) == 0
+let A = reshape(1:20, 5, 4)
+    B = sub(A, 1:4, 1:3)
+    @test findfirst(B,8) == 7
+    @test findfirst(B,5) == 0
+    @test get(findnext(B,8,start(B)))[2] == CartesianIndex((3,2))
+    @test isnull(findnext(B,5,start(B)))
+end
 
 ## findn ##
 

test/strings/search.jl

@@ -373,3 +373,7 @@ end
 # string searchindex with a two-char UTF-8 (4 byte) string literal
 @test rsearchindex("\U1f596\U1f596", "\U1f596\U1f596") == 1
 @test rsearchindex("\U1f596\U1f596", "\U1f596\U1f596", endof("\U1f596\U1f596\U1f596")) == 1
+
+# using findfirst (#15723)
+@test findfirst("⨳(",'(') == 4
+@test findfirst("⨳(",'x') == 0