I have a confession to make. I recently released two Haskell packages, lens-family-core and lens-family based on my previous blog post and Edward Kmett’s blog post. However, I never tested this code before releasing it. By “never tested”, I mean that I am pretty sure that I never once executed any of this code. I did compile it many times, and I remember once I loaded the modules in ghci in order to type check some expressions to make sure my documentation about the composition laws were correct, but I think that is it.

Worse yet, when I wrote the focus function, I actually had no idea how the function worked. I simply wrote a function that matched the required type. My original definition was the following.

focus l m = StateT $ unwrapMonad . getCompose . l (Compose . WrapMonad . (runStateT m))

All the functions used in this definition are simply newType wrappers and unwrappers that get compiled away. I figured that this code was so simple that it could not be wrong. I have never run it to find out for sure.

Now to be fair, this is a simple library and, more importantly, it is an extremely generic library. The types are so polymorphic that I conjecture that there is only one way to write functions matching the required types such that all parameters are used non-trivially and recursion is not used. Furthermore, the interface for this library is based off of the existing data-lens library.

I am not going to argue whether it is good or bad that I have never tested this code. I am just stating for the record that this is the case.