Combining lenses

Question

Using a lens library I can apply a modification function to individual targets, like so:

Prelude Control.Lens> (1, 'a', 2) & _1 %~ (*3)
(3,'a',2)
Prelude Control.Lens> (1, 'a', 2) & _3 %~ (*3)
(1,'a',6)

How can I combine those individual lenses (_1 and _3) to be able to perform this update to both of the targets at once? I expect something in the spirit of the following:

Prelude Control.Lens> (1, 'a', 2) & ??? %~ (*3)
(3,'a',6)

I'm not sure that there is a sensible implementation of such an operation. Say that the operator that combines your two lenses is `(&&&)`. It must have a type something like `(&&&) :: Lens a b -> Lens a b -> Lens a b` so that you can use it in the same way as the two lenses that you combine to make it. Given that `view _1 (1,2) = 1` and `view _2 (1,2) = 2`, what do you expect the result of `view (_1 &&& _2) (1,2)` to be? — Chris Taylor, Jul 08 '13 at 14:26
@ChrisTaylor I don't really need the "getter" functionality. Although AFAIU in this library it is conventional to approach such cases with monoid, e.g. the [Traversal](http://hackage.haskell.org/packages/archive/lens/latest/doc/html/Control-Lens-Traversal.html). — Nikita Volkov, Jul 08 '13 at 15:09
I linked this in the comments below, but in case someone misses it, there's a [lens issue](https://github.com/ekmett/lens/issues/109) about combining traversals and the trouble with it. — shachaf, Jul 09 '13 at 00:11
You cannot combine lenes, or setters safely in such a way in general because there is no way to enforce that the two lens or setters do not overlap. — Russell O'Connor, Jul 18 '13 at 12:42

bennofs · Accepted Answer · 2013-07-08T15:07:22.220

19

Using untainted from the Settable type class in Control.Lens.Internal.Setter, it is possible to combine two setters, but the result will also only be a setter and not a getter.

import Control.Lens.Internal.Setter

-- (&&&) is already taken by Control.Arrow
(~&~) :: (Settable f) => (c -> d -> f a) -> (c -> a -> t) -> c -> d -> t
(~&~) a b f = b f . untainted . a f

You can test this:

>>> import Control.Lens
>>> (1, 'a', 2) & (_1 ~&~ _3) %~ (*3)
(3,'a',6)

EDIT

You don't actually need to use internal functions. You can use the fact that Mutator is a monad:

{-# LANGUAGE NoMonomorphismRestriction #-}

import Control.Monad
import Control.Applicative

(~&~) = liftA2 (>=>)

-- This works too, and is maybe easier to understand: 
(~&~) a b f x = a f x >>= b f

edited Jul 08 '13 at 15:07

answered Jul 08 '13 at 14:40

bennofs

11,873
1
38
62

Thanks! Is there a way to maybe construct a `Traversal`? – Nikita Volkov Jul 08 '13 at 15:05
4

No. It unfortunately [doesn't really work](https://github.com/ekmett/lens/issues/109) in general. – shachaf Jul 09 '13 at 00:09
1

(_1 ~&~ _1) does not satisfy the Setter (aka SEC) laws. – Russell O'Connor Jul 18 '13 at 12:33
1

((_1 ~&~ _1) %~ ('y':)) . ((_1 ~&~ _1) %~ ('z':)) $ ("",()) === ("yyzz",()) while (_1 ~&~ _1) %~ (('y':) . ('z':)) $ ("",()) === ("yzyz",()) – Russell O'Connor Jul 18 '13 at 12:40
@RussellO'Connor So in other words, `setter1 ~&~ setter2` is only a valid setter if `setter1` and `setter2` are "orthogonal"? – Dan Burton Jul 18 '13 at 20:58

score 7 · Answer 2 · answered Jul 08 '13 at 18:00

There is a variation on what you are asking for which is more general:

(/\)
    :: (Functor f)
    => ((a -> (a, a)) -> (c -> (a, c)))
    -- ^ Lens' c a
    -> ((b -> (b, b)) -> (c -> (b, c)))
    -- ^ Lens' c b
    -> (((a, b) -> f (a, b)) -> (c -> f c))
    -- ^ Lens' c (a, b)
(lens1 /\ lens2) f c0 =
    let (a, _) = lens1 (\a_ -> (a_, a_)) c0
        (b, _) = lens2 (\b_ -> (b_, b_)) c0
        fab = f (a, b)
    in fmap (\(a, b) ->
            let (_, c1) = lens1 (\a_ -> (a_, a)) c0
                (_, c2) = lens2 (\b_ -> (b_, b)) c1
            in c2
            ) fab

infixl 7 /\

Just focus on the type signature with lens type synonyms:

Lens' c a -> Lens' c b -> Lens' c (a, b)

It takes two lenses and combines them into a lens to a pair of fields. This is slightly more general and works for combining lenses that point to fields of different types. However, then you'd have to mutate the two fields separately.

I just wanted to throw this solution out there in case people were looking for something like this.

A pithier type, for those like them `(/\) :: LensLike' ((,) a) c a -> LensLike' ((,) b) c b -> Lens' c (a, b)`. Also, the obvious restriction, `(/|\) :: LensLike' ((,) a) c a -> LensLike' ((,) a) c a -> Traversal' c a` with `a /|\ b = (a /\ b) . both`. Why aren't these in `lens`? — J. Abrahamson, Jul 09 '13 at 04:51

Combining lenses

2 Answers2

Linked