$ cabal install lens
Then, start up ghci
$ ghci GHCi, version 7.4.2: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done.
Now, you can read from lenses
and you can write to lenses.
Composing lenses for reading (or writing) goes in the order an imperative programmer would expect, and just uses
(.) from the
You can make a
Getter out of a pure functions with
Getter works like a
Lens, except you can only read from it, not write.
You can easily compose a
Getter with a
Lens just using
(.). No explicit coercion is necessary.
As we saw above, you can write to lenses and these writes can change the type of the container.
(.~) is an infix alias for
It can be used in conjunction with
(&) for a more familiar von Neumann style assignment syntax:
view, can be used as a prefix alias for
Lens comes “Batteries Included” with many lenses for manipulating common data types, such as Maps:
You can insert
and delete with this lens
You can let the library automatically derive lenses for fields of your data type
This will automatically generate the following lenses:
Lens takes 4 parameters because it can change the types of the whole when you change the type of the part.
Often you won’t need this flexibility, a
Simple Lens takes 2 parameters, and can be used directly as a
Just like how we can write a
Getter that can only be used for retrieving information, we can write a
which can only be used for updates. Like using
fmap on a
Functor updating a
Setter can modify multiple
The canonical example of a setter is ‘mapped’:
over is then analogous to
fmap, but parameterized on the Setter.
The benefit is that you can use any
Lens as a
Setter, and the composition of setters with other setters or lenses using
(%~) is an infix alias for ‘over’, and the precedence lets you avoid swimming in parentheses:
There are a number of combinators that resemble the
*=, etc. operators from C/C++ for working with the monad transformers.
*~, etc. analogues to those combinators that work functionally, returning the modified version of the structure.
There are combinators for manipulating the current state in a state monad as well
Anything you know how to do with a
Foldable container, you can do with a
There are actually a large number of variations on the concept of a
Lens provided by the library, in particular a
You can also use this for generic programming. Combinators are included that are based on Neil Mitchell’s
uniplate, but which
have been generalized to work on or as lenses, folds, and traversals.
As alluded to above, anything you know how to do with a
Traversable you can do with a
Moreover, many of the lenses supplied are actually isomorphisms, that means you can use them directly as a lens or getter:
but you can also flip them around and use them as a lens the other way with
You can automatically derive isomorphisms for your own newtypes with
will automatically derive
There are also a couple of hundred examples distributed throughout the haddock documentation.
There is also a video, covering the derivation and basic use of lenses.