Question

I don’t understand why the base case is needed in this:

-- perms :: Ord a => [a] -> [[a]]
perms [] = [[]]
perms xs = [ (x:ps) | x <- xs, ps <- perms (xs \\ [x])]

It seems to me that it should be automatic from the list-comprehension, but then I noticed that:

[ x:y | x<-[], y<-[] ]

evaluates to [], and not [[]], which seems surprising.

Even so, I was also surprised that without the base case it runs, but always gives [], which violates the type signature.
Is there an easy way to trace the execution of a list comprehension? It seems atomic to Debug.Trace.trace.

Answer 1

Let’s de-sugar!

[ x:y | x <- [], y <- [] ]

Turns into

do x <- []
   y <- []
   return (x:y)

Now, more de-sugaring! Yay!

[] >>= \x -> ([] >>= \y -> return (x:y))

iirc, >>= for lists is flip concatMap, and return is simply \x -> [x]

Let’s only do a little bit of that replacement.

concatMap (\x -> ([] >>= \y -> return (x:y))) []

There, now do you see? concatMap f [] will obviously evaluate to []. Because concatMap f is just concat . map f. So map f onto the empty list, and then concatenate the results. Except there are no results, so the final evaluation is [].