[Haskell-beginners] Lens

[Brent Yorgey]

Hi Emmanuel,

On Sun, Jul 14, 2013 at 10:47:16PM +0200, Emmanuel Surleau wrote:
> Hello there,
>
> The first (concrete) problem I ran into is how to update the members of a
> set with the result of an IO action. I have managed to do this with a pure
> function (prefixName) but I'm not sure of how to do this with
> promptName.

Unfortunately you cannot do this using a Set.  The reason is that
modifying the contents of a Set might result in a smaller Set and that
cannot possibly satisfy the lens laws.  However, if we change the Set
of dogs to be a list, we can do this using the (%%~) operator:

>   ... same as before ...
>
>   data Dogs = Dogs { _dogs :: [Dog] }
>          deriving Show
>   makeLenses ''Dogs
>
>   main :: IO ()
>   main = do
>         ... as before ...
>
>         -- change dog names by prompting the user
>         doggies' <- doggies & (dogs.traverse.name) %%~ prefixName
>         print doggies'
>
>         return ()

But astoundingly, if you look at the implementation of (%%~), it
is... (%%~) = id!  So this code also works:

  doggies' <- (dogs.traverse.name) prefixName doggies

That's right, the magic solution is to just treat the
(dogs.traverse.name) lens as a *function* and apply it to prefixName!

To understand why this works we have to look a bit at the
implementation.  I am not surprised that you were baffled by it
because it looks quite magical if you don't understand where it comes
from.

> type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t

Instead of trying to understand why this is the definition, let's just
see what happens if we take the right-hand side and set f = IO:

  (a -> IO b) -> s -> IO t

In the above example, a = b = String, and s = t = Dogs, that is,
(dogs.traverse.name) has type

  Lens Dogs Dogs String String

which expands to

  (String -> IO String) -> Dogs -> IO Dogs

(actually this is a lie, it is really just a Traversal and not a Lens,
but it's the same idea).  So if we apply it to 'prefixName :: String
-> IO String' we get a
function of type  Dogs -> IO Dogs! Nifty!

Now, to answer your specific questions:

> a) I'm not sure why the explicit forall is needed here (isn't this
> equivalent to just Functor f => ...)?

Yes, it is equivalent; the explicit forall is not strictly necessary.
The forall is there to emphasize that the 'f' does not show up on the
left-hand side: something of type  Lens s t a b  is a function which
works for *any* specific Functor f that a user might choose. (E.g., we
specifically chose IO in the example above).  So e.g. a lens cannot do
IO operations, because then it would only work for IO and not for
other Functors.  So a lens may only interact with the f via the fmap
function.  (Similarly a Traversal must work with all Applicatives, and
so on.)

> b) My understanding is that a lens packs both getter and setters, but I
> don't know which is supposed to be which here...

You can think of lenses as generalizations of getters+setters, but
that is NOT how they are implemented!  Nothing in the type (a -> f b)
-> s -> f t  corresponds directly to getters or setters.

For understanding more about what this type means and why it
corresponds to the idea of lenses, I highly recommend the video of
Edward's presentation to the NY Haskell user's group:
http://youtu.be/cefnmjtAolY?hd=1 .

> c) Is there any kind of in-depth guide to Control.Lens somewhere? I have
> found some examples and tutorials but nothing that seemed to do more than
> scratch the surface.

You can find pretty much everything there is on lens here:

  http://lens.github.io/

-Brent