List appending in Haskell - list

Question

So I wrote a function that takes a list of lists as an argument and takes every single element from the first list and appends it to a recursively called function on the list of lists' tail, in result returning all possible combinations of selecting elements from these lists.
foo :: [[a]] -> [[a]]
foo [] = [[]]
foo (x:xs) = [[(x !! a)] ++ b | a <- [0..length(x)-1], b <- foo xs]
*Main> foo [[1, 2], [3, 4], [5, 6]]
[[1, 3, 5], [1, 3, 6], [1, 4, 5], [1, 4, 6], [2, 3, 5], [2, 3, 6], [2, 4, 5], [2, 4, 6]]
It indeed works how it should, but whenever I change the second line of my function to
foo [] = []
it always returns an empty list whenever I call it on a type-valid argument. What's the big deal?

Answer 1

with foo [] = [] the very last b <- foo xs will not be able to get anything when xs == [], because it wants to pull a b from nothing - so the list-comprehension will be empty.
with the foo [] = [[]] it will finally be b <- [[]] so b will get a single [].
remark
you can simplify this a bit (so you don't need the costly (!!)):
foo :: [[a]] -> [[a]]
foo [] = [[]]
foo (xs:xss) = [ y : ys | y <- xs, ys <- foo xss]
I think this is easier to read/explain too: take every x from xs and recursively combine it with every combination of the xss into a new list
what would go wrong with foo [] = []:
Let's test it with a simple case:
foo [[1],[2]]
= [ y:ys | y <- [1], ys <- foo [ [2] ] ]
= [ 1:ys | ys <- [ y':ys' | y' <- [2], ys' <- foo [] ] ]
= [ 1:ys | ys <- [ 2:ys' | ys' <- [] ] ]
= [ 1:ys | ys <- [] ]
= []
instead of (with foo [] = [[]]):
foo [[1],[2]]
= [ y:ys | y <- [1], ys <- foo [ [2] ] ]
= [ 1:ys | ys <- [ y':ys' | y' <- [2], ys' <- foo [] ] ]
= [ 1:ys | ys <- [ 2:ys' | ys' <- [[]] ] ]
= [ 1:ys | ys <- [ 2:[] ] ]
= [ 1:[2] ]
= [ [1,2] ]