Haskell列表中的列表

Question

I'm very new on Haskell, and I'm trying the following: To obtain [1,2,3] from [[1,2,3],[4,5,6]] ?

example :: [[a]] -> [a]
example [] = []
example [x:xs] = [x]

This example is returning [1] when input is [[1,2,3]] and if I add an other element in the main List, like [[1,2,3],[3,4,5]] then I have a Non-exhaustive pattern function.

Answer 1

You are quite close. In fact what you here want is some sort of "safe" head.

A list [a] has two constructors:

1. the empty list [] , you cover this in the first case; and
2. the "cons" (x:xs) .

It looks like you cover that in the second case, but in fact you do not: you put the pattern within square brackets. As a result, Haskell interprets your pattern as [(x:xs)] . So it thinks you match a singleton list (a list with one element), and that x is the head of the sublist, and xs the tail of the sublist.

In fact you want to cover (x:xs) . If we use this pattern, there is another problem: x is the head of the list, so it has type [a] . Therefore we should return x , not [x] , since in the latter case, we would wrap the sublist back in a list.

So a correct function is:

example :: [[a]] -> [a]
example [] = []
example x:_ =   -- round brackets, x instead of [x]

Note that since we are not interested in the tail here, we use an underscore _ . If you compile with all warnings ( -Wall , or more specific -Wunused-matches ) Haskell will otherwise complain about the fact that you declare a variable that you do not use.

Generalizing to a safeHead function

We can generalize this to some sort of generic safeHead :: b -> (a -> b) -> [a] -> b function:

safeHead :: b -> (a -> b) -> [a] -> b
safeHead d _ [] = d
safeHead _ f (x:_) = f x

Here we thus pass three arguments to safeHead : a value (of type b ) we should return in case the list is empty; a function to post-process the head (type a -> b ), and the list to process . In that case the example is equivalent to:

example :: [[a]] -> [a]
example = safeHead [] id

But we can also return a Maybe [a] here:

example2 :: [a] -> Maybe a
example2 = safeHead Nothing Just