冗余模式与幺半群匹配

Question

The following function defines a pretty-concatenation of strings., ie one that does not accumulate white space:

(><) :: String -> String -> String
x >< "" = x
"" >< y = y
x >< y  = x <> " " <> y

The following ought to be the generalisation to any IsString type. Type a needs to be in the Monoid class in order to concatenate with mconcat (= <> from Semigroup ):

(><) :: (Monoid a, IsString a) => a -> a -> a
x >< mempty = x
mempty >< y = y                          -- redundant pattern match!
x >< y  = x <> (fromString " ") <> y     -- redundant pattern match!

Now, strangely, GHC warns that the second and third lines are a redundant pattern match.

This is odd. It's not even clear to me how an a that is (Monoid a, IsString a) but not Eq a can be used here.

What does work, however, is this:

(<+>) :: (Monoid a, IsString a, Eq a) => a -> a -> a
x <+> "" = x
...

Can anyone shed some light on this?

Answer 1

mempty is just a variable name here. You may as well have written

x >< y = x
x >< y = y
x >< y = ...

Haskell does not automatically do equality tests when you introduce a new pattern with the same name as an existing binding - it just shadows the existing binding. If you want equality, you have to ask for it with == tests, eg in a guard clause.

x >< y
    | x == mempty = y
    | y == mempty = x
    | otherwise = x <> " " <> y

Answer 2

Your mistake is very common when you starts with pattern matching and bonded named function. When you declare functions and its equations, all things declared at the left part of the equals written in lower case are name variables, for example:

 f sum x y = x (sum * y)

those names are confusing, because you might think that sum is a function, and x and y are numbers, but instead x is a function and sum and y are numbers, and x could be any function of type Num a -> a -> a . You cannot give a concrete kind of function in the left side.

so :

(><) :: (Monoid a, IsString a) => a -> a -> a
x >< mempty = x
mempty >< y = y                          -- redundant pattern match!
x >< y  = x <> (fromString " ") <> y     -- redundant pattern match!

there, mempty is just a name for you variable and not the actual mempty function you are trying to call. You cannot pattern match over a functions of an interface. Just over variables and data types-