Haskell列表中的Zip元素

Question

I have a problem with the following function in Haskell that zip only elements "B" in a list:

data El = A | B deriving (Show)

zS :: [El] -> [El]
zS [] = []
zS (A:xs) = A : zS xs
zS (B:xs) = B : zS xs
zS (B:B:xs) = B : zS xs
zS (B:A:xs) = B : A : zS xs

When I test the function zS the result should be:

zS [B, B, A, A, B, B, B, A, B ] --> [B, A, A, B, A, B ]

but it does not work. Also, when I compile the code, Haskell return a Warning like this:

 Warning:
    Pattern match(es) are overlapped
    In an equation for 'zS':

How can I fix this?

Answer 1

TL;DR

When you define a function with multiple patterns, the patterns which are too specific should be defined at the beginning and the broader patterns should be defined at the end.

Explanation

In your case,

zS (B:xs) = B : zS xs

already matches any list which starts with B . So,

zS (B:B:xs) = B : zS xs
zS (B:A:xs) = B : A : zS xs

will already be matched by zS (B:xs) = B : zS xs itself. That is why Haskell is calling it out by saying

Pattern match(es) are overlapped

To fix this, define the specific patterns at the beginning, like this

zS :: [El] -> [El]
zS [] = []
zS (B:B:xs) = B : zS xs
zS (B:A:xs) = B : A : zS xs
zS (A:xs) = A : zS xs
zS (B:xs) = B : zS xs

---

Note: Your code has a bug,

zS (B:B:xs) = B : zS xs

Here, you are including B , if you find two matches and no matter how many times B is repeated. Instead, you can recurse like this

zS (B:B:xs) = zS (B:xs)

so that

zS (B:A:xs) = B : A : zS xs

will take care of repeating B s for you.