使Haskell List Recursion函数更有效

Question

I've written a function that will compare two lists and check to see if the first is a prefix of the second and it must be done using recursion.

For example:

prefix [1,2] [1,2,3]
>True
prefix [2,1,4] [2,1,13,4]
>False

Now I've done this but I feel it's inefficient:

prefix :: [Int] -> [Int] -> Bool
prefix (x:xs) (y:ys)
|   null xs                         =   True
|   x == y && head xs == head ys    =   True && prefix xs ys
|   head xs /= head ys              =   False

I was hoping it could be done more efficiently and with some better pattern matching. Can it be?

Answer 1

You don't need to use the head function at all. That doubles the number of comparisons. Try this:

prefix :: [Int] -> [Int] -> Bool
prefix [] _ = True
prefix _ [] = False
prefix (x:xs) (y:ys)
  | x == y = prefix xs ys
  | otherwise = False

Answer 2

Chad Gilbert's solution can be streamlined very slightly:

prefix :: [Int] -> [Int] -> Bool
prefix [] _ = True
prefix (x:xs) (y:ys)
  | x == y = prefix xs ys
prefix _ _ = False

This won't affect the performance, but it demonstrates a language feature: when all the guards on a pattern fail, that match will be abandoned and matching will resume with the next pattern.

Answer 3

 Prelude > let prefix [] _ = True
 Prelude |     prefix _ [] = False
 Prelude |     prefix (x:xs) (y:ys) = if ( x==y) then prefix xs ys else False

Examples:

  Prelude> prefix [1,3] []
  False
  Prelude> prefix [] [1,2,3]
  True
  Prelude> prefix [1,2] [1,2,3]
  True