Having "solved" a bunch of these divide & conquer problems, I'm the first to admit to having being lulled into a false sense of security. At first glance, the problem of this post seemed deceptively simple and consequently I struggled with it, sort of "hand-waving", not really engaging my brain and getting more and more frustrated how the dang thing wouldn't yield to my experience! I think the moral of the story is math doesn't care about your previous successes and so don't let your past practice trick you into laziness. Be guided by your experience but fully apply yourself to the problem at hand!

Suppose a set of two elements *{2, 3}*. There are only two ways it can be partitioned: *(23), (3)(2)*. For meaning, you might think of these two partitions like this : in the first partition, there is a connection between the elements *2* and *3*, in the second, *2* and *3* are isolated from each other.

Suppose a set of elements *{1, 2, 3}*. There are five partitions of this set : *(123), (23)(1), (13)(2), (3)(21), (3)(2)(1)* (I've carefully written them out this way to help with the elucidation). Maybe you want to break here and see if you can write an algorithm for calculating them before reading on?

Observe that we can get the partitions of *{1, 2, 3}* from knowledge of the partitions of *{2, 3}* by looking at each partition of *{2, 3}* in turn and considering the partitions that would result by inclusion of the element *1*. So, for example, the partition *(23)* gives rise to the partitions *(123)* and *(23)(1)*. Similarly, the partition *(3)(2)* gives rise to the partitions *(13)(2)*, *(3)(21)* and *(3)(2)(1)*. We might characterize this process as computing new partitions of *{1, 2, 3}* from a partition *p* of *{2, 3}* as "extending" *p* .

Suppose then we write a function `extend x p`

to capture the above idea. Let's start with the signature of `extend`

. What would it be? Taking *(23)(1)* as an exemplar, we see that a component of a partition can be represented as `[a]`

and so a partition itself then as `[[a]]`

. We know that `extend`

takes an element and a partition and returns a list of (new) partitions so it must have signature `extend :: a -> [[a]] -> [[[a]]]`

(yes, lists of lists of lists are somehow easy to get confused about).

Now for writing the body of `extend`

. The base case is the easiest of course - extending the empty partition:

```
extend x [] = [[[x]]]
```

That is, a singleton list of partitions where that one partition has one component. The inductive case is the partition obtained by "pushing" `x`

into the first component of `p`

together with the extensions that leave the first component of `p`

alone.
```
extend x (h : tl) = ((x : h) : tl) : map (h :) (extend x tl)
```

We can now phrase the function `partition`

with signature `partition :: [a] -> [[[a]]]`

like this:

```
partition [] = [[]]
partition (h : tl) = concatMap (extend h) (partition tl)
```

The base case says, the only partition of the empty set is the the empty partition.
Wrapping it all up, the algorithm in entirety is

```
partition :: [a] -> [[[a]]]
partition [] = [[]]
partition (h : tl) = concatMap (extend h) (partition tl)
where
extend :: a -> [[a]] -> [[[a]]]
extend x [] = [[[x]]]
extend x (h : tl) = ((x : h) : tl) : map (h :) (extend x tl)
```