A version of findIndex for the last matching element.

Discussed in

haskell#172

Data/Vector/Generic.hs

@@ -105,7 +105,7 @@ module Data.Vector.Generic (
   partition, partitionWith, unstablePartition, span, break,
 
   -- ** Searching
-  elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
+  elem, notElem, find, findIndex, findIndexR, findIndices, elemIndex, elemIndices,
 
   -- * Folding
   foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
@@ -1468,6 +1468,12 @@ findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int
 {-# INLINE findIndex #-}
 findIndex f = Bundle.findIndex f . stream
 
+-- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate
+-- or 'Nothing' if no such element exists.
+findIndexR :: Vector v a => (a -> Bool) -> v a -> Maybe Int
+{-# INLINE findIndexR #-}
+findIndexR f v = fmap (length v - 1 -) . Bundle.findIndex f $ streamR v
+
 -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
 -- order.
 findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int

tests/Tests/Vector.hs

@@ -183,7 +183,7 @@ testPolymorphicFunctions _ = $(testProperties [
 
         -- Searching
         'prop_elem, 'prop_notElem,
-        'prop_find, 'prop_findIndex, 'prop_findIndices,
+        'prop_find, 'prop_findIndex, 'prop_findIndexR, 'prop_findIndices,
         'prop_elemIndex, 'prop_elemIndices,
 
         -- Folding
@@ -330,6 +330,10 @@ testPolymorphicFunctions _ = $(testProperties [
     prop_find    :: P ((a -> Bool) -> v a -> Maybe a) = V.find `eq` find
     prop_findIndex :: P ((a -> Bool) -> v a -> Maybe Int)
       = V.findIndex `eq` findIndex
+    prop_findIndexR :: P ((a -> Bool) -> v a -> Maybe Int)
+      = V.findIndexR `eq` (\p l -> case filter (p . snd) . reverse $ zip [0..] l of
+                                     (i,_):_ -> Just i
+                                     []      -> Nothing )
     prop_findIndices :: P ((a -> Bool) -> v a -> v Int)
         = V.findIndices `eq` findIndices
     prop_elemIndex :: P (a -> v a -> Maybe Int) = V.elemIndex `eq` elemIndex