I had a data structure with a redundant field [1]. I refactored to make that field go away. Here is the code [2]. The following is a simplification of it.
I was using this type:
data X = X1 | X2 Int
To make the Int go away, I made a duplicate type:
data X' = X1' | X2'
Then, every function for which any argument was of type X, I similarly duplicated, replacing every X with X', X1 for X1', and X2 for X2'. Next I had to similarly duplicate every function that used one of those. And so on, and so on ... until eventually I was duplicating the tests. At that point I was able to determine from the duplicate tests that everything was working.
There was a little more work involved than that, but the vast, vast majority of the edits that got me there were the simple duplication I just described.
I looked once at automatic refactoring in Haskell and was either unimpressed or scared. I may not have understood what I was looking at enough to appreciate its power. Is there something that can do the refactoring described above?
[1] The Int in a Tplt could be inferred from context, so keeping a duplicate of that information in the Tplt was dangerous, because it makes invalid state possible (e.g. if one is updated and not the other). So I decided to stop using it.
--