Haskell - 通过比较过滤列表

Question

I need to filter a list with a mask in Haskell.

It applies the function to an element of the mask list and the corresponding element in the data list, and if the function returns true, the corresponding element in the data list is included in the returned list.

For example, suppose I want to filter out data items that are greater than the mask items:

filtermask (\m d -> d > m) [1, 5, 7] [5, 6, 7]→[5, 6]

Any possible solution to this problem would be fantastic. So far, I've only done

 filtermask f m d = f m d

That returns TRUE

EDIT: Solution, thanks to help from Tikhon:

filtermask f [] [] = []
filtermask f (fm:rm) (fd:rd)
  |f fm fd = fd:filtermask f rm rd
  |otherwise = filtermask f rm rd

Answer 1

Fundamentally, what you want to do is first pair up each element of the mask with an element of the list. We can do this with zip , which gives us a list of pairs.

Now that we have a list of pairs, we want to filter this using the comparison function ( > , or whatever). The > function has a type Ord o => o -> o -> Bool ; we need to turn this into a function which accepts a tuple. Happily, we can do this with uncurry ; uncurry (>) gives us a function of type Ord o => (o, o) -> Bool .

Since we already have a list of pairs, we can just use this function to filter it. Now we have a list of only the pairs we want to keep; we need to get a list of just the element. We can do this by mapping a projection function like fst over the list.

Putting it all together, we get:

filterMask :: (o -> o -> Bool) -> [o] -> [o] -> [o]
filterMask fn mask list = map fst (filter (uncurry fn) (zip list mask))

There's just one more subtle trick: what happens if the mask is shorter than our input list? With this function, the rest of the input list will be thrown out. If this is not what you want, you will need to repeat the mask. We can do this with a neat function called cycle which repeats a list forever. So that version would be:

filterMask fn mask list = map fst (filter (uncurry fn) (zip list (cycle mask)))

Answer 2

As you problem is design, two list of the same size, and a function working and their element, using the zip function is a good starting point. It's work like this,

# zip [1,2,3] [4,5,6] 
[(1,4),(2,5),(3,6)]

Then, for each tuple, you have to check if the predicate is fill or not.
It's like to apply a zip with a function, there is a function for that.

# zipWith (\x y -> x + y) [1,2,3] [4,5,6] 
[5,7,9]

But, the applied function is a more than the one provided.
And, what are we supposed to do if the predicate is not satisfied ?
These two point are manage by a conditional statement and Maybe type.
Finally we obtain a list containing, two kind of value Nothing and Just x, and we'd like to keep the last one. catMaybe do the job.

# filtermask f m d = catMaybes $ zipWith (\x y -> if f x y then Just y else Nothing) m d

Answer 3

The problem should be broken down into two parts:

1. Producing the boolean mask from comparing the two lists
2. Filtering one of the lists based on the boolean mask

For 1, you can use zipWith . For 2, you can use maskFilter :

maskFilter :: [Bool] -> [a] -> [a]
maskFilter mask xs = [x | (m,x) <- zip mask xs, m]

For your example, you can use

let
    xs = [1,5,7]
    ys = [5,6,7]
    mask = zipWith (>) ys xs
in
    maskFilter mask ys