Your answer is one click away!

Al Pimenov February 2016
### (x:xs) pattern Haskell logic

Let's say there is a simple function:

```
maximum' :: (Ord a) => [a] -> a
maximum' [] = error "maximum of empty list"
maximum' [x] = x
maximum' (x:xs) = max x (maximum' xs)
```

I understand the idea and what (x:xs) does. As it was explained in details here
What do the parentheses signify in (x:xs) when pattern matching?
but there is one little thing that I cannot get out of my head. Since *cons*: operator appends x to a list xs, **why is it that x is the first element of function argument list and xs is the tail when we use (x:xs)???** as if (x:xs) calls head and tail on argument list.

Louis Wasserman February 2016

This is just an instance of the general pattern that the constructor for a type is both used to construct elements of that type and to deconstruct. If you wrote

```
data MyList a = Empty | Cons a (MyList a)
```

you'd write

```
maximum' :: (Ord a) => MyList a -> a
maximum' Empty = error "maximum of empty list"
maximum' (Cons x Empty) = x
maximum' (Cons x xs) = max x (maximum' xs)
```

Except that lists are actually defined equivalently to

```
data [a] = [] | a:as
```

so, just as with other data types, `:`

is used both to construct and to deconstruct nonempty lists.

sepp2k February 2016

The cons operator doesn't append, it prepends. That is `x : xs`

produces a list that contains `x`

as its first element and `xs`

as the rest. Therefore the pattern `x : xs`

likewise matches a list with `x`

as the first element and `xs`

as the rest.

Asked in February 2016

Viewed 3,537 times

Voted 5

Answered 2 times

Viewed 3,537 times

Voted 5

Answered 2 times