# Wiggling Sums

## The problem

The context of this problem is related to optimization problems: given some value, we want to produce a bunch of related values.

An example of where such an operation can be found is `shrink :: Arbitrary a => a -> [a]`

, found in the QuickCheck library.

Alex and I encountered an fun problem while working on something similar at Tsuru. This blogpost is not really aimed at people who have just begun reading about Haskell as it contains little text and requires some intuition about sums and products (in the more general sense).

```
> {-# LANGUAGE FlexibleInstances #-}
> import Control.Applicative
> import Data.Traversable
```

We can capture our idea of related values in a typeclass:

```
> class Wiggle a where
> wiggle :: a -> [a]
```

And define a simple instance for `Int`

or `Double`

:

```
> instance Wiggle Int where
> wiggle x = [x - 1, x, x + 1]
```

```
> instance Wiggle Double where
> wiggle x = let eps = 0.03 in [x - eps, x, x + eps]
```

The interesting notion is to define instances for more general (combined) types. Given a tuple, we can wiggle it in two ways: either wiggle one of its components, or wiggle them both. Let’s express both notions using two simple newtypes ^{1}:

```
> newtype Product a = Product {unProduct :: a}
> deriving (Show)
```

```
> instance (Wiggle a, Wiggle b) => Wiggle (Product (a, b)) where
> wiggle (Product (x, y)) =
> [Product (x', y') | x' <- wiggle x, y' <- wiggle y]
```

```
> newtype Sum a = Sum {unSum :: a}
> deriving (Show)
```

```
> instance (Wiggle a, Wiggle b) => Wiggle (Sum (a, b)) where
> wiggle (Sum (x, y)) =
> [Sum (x', y) | x' <- wiggle x] ++
> [Sum (x, y') | y' <- wiggle y]
```

The same applies to structures such as lists. We can wiggle all elements of a list, or just a single one (if the list is non-empty). Both instances are reasonably straightforward to write.

The interesting question is if and how we can do it for a more general family of structures than lists? `Foldable`

? `Traversable`

?

A `Wiggle`

instance for traversable products is not that hard:

```
> instance (Traversable t, Wiggle a) => Wiggle (Product (t a)) where
> wiggle (Product xs) = map Product $ traverse wiggle xs
```

But how about the instance:

```
> instance (Traversable t, Wiggle a) => Wiggle (Sum (t a)) where
> wiggle = wiggleSum
```

## The solution

Is it possible? Can you come up with a nicer solution than we have?

These newtypes are also defined in

`Data.Monoid`

. I defined them again here to avoid confusion: this code does not use the`Monoid`

instance in any way.↩