Lenses don't seem to have any disadvantages while having significant advantages over standard Haskell: Is there any reason I shouldn't use lenses wherever possible? Are there performance considerations? Additionally, does template Haskell have any significant overhead?
Your peripheral and central vision will be better with contact lenses. Because contacts conform to the curvature of your eye, they provide a wider field of view with less distortion and viewer obstructions than glasses. Contact lenses also reduce image distortion and glare reflections.
Wearing contact lenses puts you at risk of several serious conditions including eye infections and corneal ulcers. These conditions can develop very quickly and can be very serious. In rare cases, these conditions can cause blindness.
Lenses form an alternative to using direct closures over data constructors. Lenses therefore have approximately the same caveats as using functions and data constructors directly.
Some of the cons because of this:
Every time you modify a lens, you might potentially cause a lot of objects to be (re)created. For example, if you have this data structure:
A { B { C { bla = "foo" } } }
...and the lens of type Lens A String
, you will create a new A
, B
and C
every time you "modify" that lens. This is nothing unusual in Haskell (creating lots of objects), but the object creation is hidden behind the lens, making it hard to spot as a potential performance sink.
And the pros:
data-lens-fd
for an example), and this makes it possible to avoid recreating a lot of objects most of the time, due to extensive data sharing. See for example the focus
function, and a similar pattern of using withSomething
functions in the Snap Web framework.Lenses are not always isomorphic to closures over data constructors, however. Here are some of the differences (taking data-lens
as the implementation here):
data-lens
, it's the Store
comonad. This means that every time you create a lens, there'll be a very small extra overhead due to that data structure being created.Template Haskell code runs at compile time, and does not affect the runtime performance of lenses whatsoever.
I'm assuming the data-lens package. Lenses performed very well for me for data-like things (records, tuples, maps, etc.). In fact they sometimes even performed better than the normal approach, probably because of better sharing. In terms of performance it produces about the same performance as the code you would have written by hand.
However, there are function-like things, for which lenses can have a penalty. For example I remember at least once using a lens like this one:
result :: (Eq a) => a -> Lens (a -> b) b
While queries were very fast, I occasionally overrode certain result values of the function to adjust it to particular scenarios, which is equivalent to enclosing the function's body in a large if
. The performance implications are not related to lenses themselves, of course, but it is something noteworthy.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With