获取Haskell中字符串列表中元素的位置

Question

my title might be a bit off and i'll try to explain a bit better what i'm trying to achieve.

Basically let's say i have a list:

["1234x4","253x4",2839",2845"]

Now i'd like to add all the positions of the strings which contain element 5 to a new list. On a current example the result list would be:

[1,3]

For that i've done similar function for elem :

myElem [] _ = False
myElem [x] number =
  if (firstCheck x) then if digitToInt(x) == number then True else False else False
myElem (x:xs) number =
if (firstCheck x) then (if digitToInt(x) == number then True else myElem xs number) else myElem xs number

where firstCheck x checks that the checked element isn't 'x' or '#'

Now in my current function i get the first element position which contains the element, however my head is stuck around on how to get the full list:

findBlock (x:xs) number arv =
  if myElem x number then arv else findBlock xs number arv+1

Where arv is 0 and number is the number i'm looking for.

For example on input:

findBlock ["1234x4","253x4",2839",2845"] 5 0 

The result would be 1

Any help would be appreciated.

Answer 1

The function you want already exists in the Data.List module, by the name of findIndices . You can simply use (elem '5') as the predicate.

http://hackage.haskell.org/package/base-4.8.1.0/docs/Data-List.html#v:findIndices

If, for some reason, you're not allowed to use the built-in one, it comes with a very pretty definition (although the one actually used has a more complicated, more efficient one):

findIndices p xs = [ i | (x,i) <- zip xs [0..], p x]

By the way, I found this function by searching Hoogle for the type [a] -> (a -> Bool) -> [Int] , which (modulo parameter ordering) is obviously the type such a function must have. The best way to find out of Haskell has something is to think about the type it would need to have and search Hoogle or Hayoo for the type. Hoogle is better IMO because it does slightly fuzzy matching on the type; eg Hayoo wouldn't find the function here by the type I've given, because it take the arguments in the reverse order.

Answer 2

An implementation of findIndices , for instructional purposes:

findIndices ok list = f list 0 where
  f [] _ = []
  f (x:xs) ix
    | ok x      = ix : f xs (ix+1)
    | otherwise =      f xs (ix+1)

Use it like findIndices (elem '5') my_list_o_strings

Answer 3

You're trying to work your way through a list, keeping track of where you are in the list. The simplest function for doing this is

mapWithIndex :: (Int -> a -> b) -> [a] -> [b]
mapWithIndex = mwi 0 where
  mwi i _f [] = i `seq` []
  mwi i f (x:xs) = i `seq` f i x : mwi (i+1) f xs

This takes a function and a list, and applies the function to each index and element. So

mapWithIndex (\i x -> (i, x)) ['a', 'b', 'c'] =
[(0,'a'), (1,'b'),(2,'c')]

Once you've done that, you can filter the list to get just the pairs you want:

filter (elem '5' . snd)

and then map fst over it to get the list of indices.

A more integrated approach is to use foldrWithIndex .

foldrWithIndex :: (Int -> a -> b -> b) -> b -> [a] -> b
foldrWithIndex = fis 0 where
  fis i _c n [] = i `seq` n
  fis i c n (x:xs) = i `seq` c i x (fis (i+1) c n xs)

This lets you do everything in one step.

It turns out that you can implement foldrWithIndex using foldr pretty neatly, which makes it available for any Foldable container:

foldrWithIndex :: (Foldable f, Integral i) =>
  (i -> a -> b -> b) -> b -> f a -> b
foldrWithIndex c n xs = foldr go (`seq` n) xs 0 where
  go x r i = i `seq` c i x (r (i + 1))

Anyway,

findIndices p = foldrWithIndex go [] where
  go i x r | p x = i : r
           | otherwise = r