Haskell ::递归中使用括号

Question

I'm just wondering, for recursion example:

squaresRec :: [Double] -> [Double]   
squaresRec [] = []                       
squaresRec (x:xs) = x*x : squaresRec xs

Why on the recursive case, there is no bracket? Shouldn't it suppose to be like this:

squaresRec :: [Double] -> [Double]   
squaresRec [] = []                       
squaresRec [x:xs] = x*x : squaresRec xs

I know this will not work. But just wondering the explanation behind it.

Answer 1

[] matches the empty list.

[1] matches a list containing exactly one element, and that must be a number equal to one. Note that [1] is actually syntactic sugar for (1:[]) , ie what this really matches is: a list beginning with the number 1 , followed by a list that is empty... which is just a complicated way of saying “a list containing the single element 1 ”.

(x:xs) matches a list that begins with x , followed by xs (and that may contain any number of elements, possibly zero). Ie this pattern matches any list with at least one element.

[x:xs] matches again a list which contains exactly one element, and that element should match the pattern (x:xs) . (Which doesn't make sense even type-wise, because your lists contain Double -numbers, not lists.)

Answer 2

I had the same problem because I'm coming from Erlang.

The thing to understand is that the [head|tail] pattern we have in Erlang is actually translated by the cons function in Haskell, which is the : operator. The parenthesis are just here to isolate the function parameters, like (3+4) would do.

I know it's tempting to ask "why though???" and that it visually makes more sense, but : is how we build (and separate when pattern-matching) the head and the tail of a linked list.