elemIndices in Haskell

Question

I wrote the code to get the element index

elemIndex :: [String] -> [String] -> [Int]
elemIndex [] [] = []
elemIndex x y = elemIndex True [(elem a y) | a <- x ]

is there any alternative way/similer of performing the above logic?

and also i've seen that some use

index [] _ = []

to return null lists

could you pls explain the use of underscore?

//edit 1 it is suposed to return the index of the values in the list.

eg: elemIndex ["asde","zxc","qwe"] ["qwe","zxc"]

returns [1,2] as the answer

thanks

Answer 1

index [] _ = []

is the same as

index [] x = []

except you cannot use the _ on the right hand side of the equals sign.

I don't understand what you want elemIndex to do.

Answer 2

elemIndex takes two arguments (two lists). Right now you recursively call it with an additional argument of type bool (namely True). That will not work. What you probably want to do, is create a helper function, as I showed you an hour ago.

The _, as used as a formal argument, matches any input. It does not have a name, and as such, you cannot use that which is matched.

Aside from that, you probably don't want to use booleans, but integers (to keep track of a counter). The elem function only tells you whether some value is part of a list, not where it is. So, it is of little use to you. Since this appears to be homework I will not provide a solution to your problem, but perhaps you should split your code in two:

indices :: (Eq t) => [t] -> [t] -> [Integer]
getIndex :: (Eq t) => [t] -> t -> Integer

(getIndex may use a helper function getIndex' :: (Eq t) => [t] -> t -> Integer -> Integer.)

---

Edit: One possible solution (which uses a hack, it's nicer to use the Maybe monad):

indices :: (Eq t) => [t] -> [t] -> [Integer]
indices xs ys = filter (>= 0) $ map (getIndex xs) ys

getIndex :: (Eq t) => [t] -> t -> Integer
getIndex xs y = getIndex' xs y 0
  where
    getIndex' :: (Eq t) => [t] -> t -> Integer -> Integer
    getIndex' [] _ _                 = -1
    getIndex' (x:xs) y i | x == y    = i
                         | otherwise = getIndex' xs y (i + 1)

A version with the Maybe monad:

import Data.Maybe

indices :: (Eq t) => [t] -> [t] -> [Integer]
indices xs ys = mapMaybe (getIndex xs) ys

getIndex :: (Eq t) => [t] -> t -> Maybe Integer
getIndex xs y = getIndex' xs y 0
  where
    getIndex' :: (Eq t) => [t] -> t -> Integer -> Maybe Integer
    getIndex' [] _ _                 = Nothing
    getIndex' (x:xs) y i | x == y    = Just i
                         | otherwise = getIndex' xs y (i + 1)

And a version that leaves all heavy lifting to the standard library:

import Data.List
import Data.Maybe

indices :: (Eq t) => [t] -> [t] -> [Int]
indices xs ys = mapMaybe (`elemIndex` xs) ys

Answer 3

I'd implement your function this way:

elemIndices acc n []  _ = acc
elemIndices acc n  _ [] = acc
elemIndices acc n (x:x') (y:y') = if x == y then 
                                      elemIndices (n:acc) (n+1) x' y'
                                  else
                                      elemIndices acc (n+1) x' (y:y')

elemIndex x y = reverse $ elemIndices [] 1 x y

When the elements in your source list are in the same order as the elements you look for, this is much more efficient (no use of elem - tail recursion). Ex:

elemIndex [3..7] [4, 6] -- Yields [2, 4]