在单个模式匹配中指定多个替代项？

Question

Take the following function as an example (the function is quite meaningless but at least illustrates my question).

myFunction :: [x] -> x
myFunction [] = "result"
myFunction [x] = "result"
myFunction (_:xs) = myFunction xs
...

Since myFunction [] and myFunction x matches produce the same result, is it possible to combine these into a single pattern-match rather than writing each one on a separate line and cut/pasting the result? Something like an "OR" operand:

myFunction [] || x = "result"

Answer 1

Not as such, but there are a couple of alternatives to write it with one clause:

myFunction' (_:xs@(_:_)) = foo xs -- note the changed order: `_:...` first, thus
myFunction' _ = "result"          -- you'll get "result" for _every_ other input

myFunction'' xs | null $ drop 1 xs  = "result"  -- or `| [] <- drop 1 xs`
myFunction'' (_:xs) = foo xs

myFunction''' xs' = case drop 1 xs' of
       [] -> result
       xs -> foo xs

Answer 2

I should tell you that your myFunction doesn't actually typecheck. It should be like this:

myFunction :: [a] -> String
myFunction [] = "result"
myFunction [x] = "result"
myFunction (_:xs) = myFunction xs

That being said, what you want to do can be achieved through guards:

myFunction :: [a] -> String
myFunction xs
  | (null xs) || (length xs == 1) = "result"
  | otherwise = myFunction (tail xs)

Or a more efficient one in which you don't have to traverse the entire list:

 myFunction :: [a] -> String
    myFunction xs
      | (null xs) || null (tail xs) = "result"
      | otherwise = myFunction (tail xs)

Answer 3

How about this? Short and sweet:

{-# LANGUAGE ViewPatterns #-} 

myFunction ((<2) . length -> True) = "result"
myFunction _ = "other result"

You can replace (<2) . length (<2) . length by any other function of type [a] -> Bool , of course, including lambdas . As written, your example would probably be more precisely represented with first case

myFunction (\xs -> null xs || length xs == 1 -> True) = "result"
myFunction _ = "other result"

This is breaks for infinite lists, but that shouldn't be too hard to solve.

---

Finally, if you also enable the LambdaCase extension, you can even write

{-# LANGUAGE ViewPatterns, LambdaCase #-} 

myFunction (\case { []->True ; [x]->True ; _->False } -> True) = "result"
myFunction _ = "other result"

That's getting unreadable and error prone (you have to make sure the \\case expression is total! ) but it does combine two patterns into one, with only constant overhead. Don't do this, please :-)