State of Monocle
In Monocle, we experimented with various optics encoding: pair of functions, Van Laarhoven, and profunctor (see LensImpl). The JVM and Haskell runtime are hugely different, and an encoding that works well in Haskell can be inefficient in Scala. For example, Haskell relies on zero cost wrapper (newtype) to effectively select typeclass instances, but we don't have an equivalent in Scala/JVM yet (opaque types may help). You can find some of the benchmarks we made for Lenses in 2015 here.
However, something we didn't do very well was to adapt the API to the specificity of Scala. If you look at Monocle 1.x or 2.x, it has the same interface as Haskell Lens but expressed in a much more clunky way. The example of this can be seen in optics composition, i.e. how we build complex optics out of simpler ones.
They are two main reasons why Monocle has a worse interface than Haskell Lens.
1. Optics in Lens are type aliases
All optics in Haskell Lens are type aliases for fancy functions, e.g.
The entire Haskell library is designed for optics composition to be "just" function composition (
. in Haskell).
It also means one can define an optic without depending on thes Lens library. Unfortunately, we cannot use this
encoding in Scala 2; we would need polymorphic functions which we may have in Scala 3.
2. Overloaded methods have type inference issues
Almost all optics compose together, see table:
We could define overloaded compose methods, one for each valid combination of optics.
Sadly, there is a bug in Scala 2 that makes the type inference weaker with overloaded methods (see issue). There is an easy workaround; we can use non-overloaded compose methods, e.g.
The type inference now works, but the API is much more verbose. Fortunately, Dotty fixed this issue so we can expect a single overloaded compose method in Monocle for Scala 3.
In September, we kicked out the development of a new major version for Monocle. The main goal of Monocle 3.x is to make the API user-friendly. To do this, we will rewrite the library from scratch and try to leverage Scala features such as inheritance, class methods, and variance. More in my next post, stay tuned.
If you would like to participate in the development of Monocle, we are always looking for new contributors and active maintainers. You don't necessarily need to be an expert in optics. We also need help to create benchmarks, documentation, tutorials, and general API feedback.