Haskell：中缀（`：`）运算符是否有左侧标识？

Question

In other words, what syntax (if any) could I use in place of XXX in the following implementation of filter:

filter' :: (a -> Bool) -> [a] -> [a]
filter' _ []     = []
filter' f (x:xs) =
  let n = if f x then x else XXX
  in  n:(filter' f xs)

I'm aware of the following alternative implementation (which is recursive and only prepends) but would still be curious if the infix operator has a LHS identity.

filter' :: (a -> Bool) -> [a] -> [a]
filter' _ []     = []
filter' f (x:xs)
  | f x = x:(filter' f xs)
  | otherwise = filter' f xs

Answer 1

There is none. This can be seen because

ghci> length (undefined : [])
1

so no matter what element you put there, you will always get a length of 1.

How about this phrasing:

filter' f (x:xs) =
    let n = if f x then (x:) else id
    in  n (filter' f xs)

Answer 2

Handwave alert: the following is strictly speaking a lie (because of undefined and such), but it's still a useful idea.

One key property of types defined with Haskell data declarations is that they are free : the set of values for a data type is isomorphic to the set of normal-form terms (fully evaluated expressions) of that type. If two terms of the type are different, then they have different values.

From this it follows that x : xs and xs (in the same scope) must be different lists, simply because they are different terms.

Put a bit differently, the semantics of data types is that if you pattern match on a constructor application you always get back the same constructor and its arguments. For example, these two expressions are guaranteed to be True , no matter what x and xs may be:

case [] of
    []   -> True
    x:xs -> False

case (x:xs) of
    []     -> False
    x':xs' -> x == x' && xs == xs'

The left identity value you're looking for would be a counterexample to the second expression here. Ergo, no such value exists.

Answer 3

There is none, but ++ does have an identity, namely [] . So this would work as well:

filter' _ [] = []
filter' f (x:xs) =
     let n = if f x then [x] else [] 
     in n ++ (filter' f xs)

This is the same as @luqui's answer (as you could prove) only less efficient , but it keeps things a bit lower-order.