Haskell中的函数snd如何在过滤器中起作用

Question

I type this code to ghci

Prelude> filter snd [('a',True),('b',True),('c',False),('d',True)]

why it returns

[('a',True),('b',True),('d',True)]

rather than

[('a',True),('c',False),('d',True)]

snd function returns the second item, so why not filter snd filter the second item?

Answer 1

You expect filter to "filter out" elements from a list in the colloquial sense of that expression, and thus filter snd to remove the second item.

That is not how it works

If you were right, filter snd [1,2,3] would evaluate to [1,3] . Instead, it doesn't typecheck, as snd works on tuples, not on numbers.

So, how does it work?

filter f [item1, item2, ...] returns a list of all item s for which f item is True

For example, filter even [1,2,3,4] returns [2,4]

As snd ('b', True) evaluates to True , in your example filter will include (b, True) in the result. By the same token, (c, False) will be omitted

Answer 2

In short : filter snd retains 2-tuples where the second item of the tuple is True .

filter :: (a -> Bool) -> [a] -> [a] takes as parameter a function that maps elements of type a to a Bool . In case the Bool is True it will retain the element of the original list in the result, otherwise that element will not be part of the result.

filter thus filters elementwise : it does not take into account the next or previous element(s) in the list. It simply checks if a predicate on an element is satisfied.

Since you here have a list of 2-tuples where the second item of each tuple is a Bool , the snd :: (a, b) -> b will thus map each element on the second element, and thus retain 2-tuples where the second item of the 2-tuple is True . The most generic type of filter snd is thus filter snd :: [(a, Bool)] -> [(a, Bool)] , since the second item of the 2-tuples should be a Bool .

This thus means that filter snd indeed will filter like:

Prelude> filter snd [('a',True),('b',True),('c',False),('d',True)]
[('a',True),('b',True),('d',True)]

We can filter out every second element with explicit recursion for example:

filterAtEven :: [a] -> [a]
filterAtEven [] = []
filterAtEven (x:xs) = x : filterAtOdd xs

filterAtOdd :: [a] -> [a]
filterAtOdd [] = []
filterAtOdd (_:xs) = filterAtEven xs

for example:

Prelude> filterAtEven [('a',True),('b',True),('c',False),('d',True)]
[('a',True),('c',False)]
Prelude> filterAtOdd [('a',True),('b',True),('c',False),('d',True)]
[('b',True),('d',True)]

Or if you want to remove a specific index, we can make use of deleteAt :: Int -> [a] -> [a] of the ilist package:

Prelude> import Data.List.Index
Prelude Data.List.Index> deleteAt 2 [('a',True),('b',True),('c',False),('d',True)]
[('a',True),('b',True),('d',True)]

or we can implement this ourselves:

deleteAt :: Int -> [a] -> [a]
deleteAt i | i < 0 = id
           | otherwise = go i
  where go _ [] = []
        go 0 (_:xs) = xs
        go n (x:xs) = x : go (n-1) xs

Answer 3

Your filter function filters your list according to the second value of each pair. This is why ('c',False) is filtered out ...