Lenses with interdependent (simultaneous) updates

Question

Lets say I have:

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TupleSections #-}
import Control.Lens

data T a b = T { _foo :: a
               , _bar :: a -> b
               }

makeLenses ''T

a appears in both foo and bar, so updates have to be "simulatenous", as it were. This is possible without lenses:

eg1 :: T a (b -> c) -> b -> T (a, b) c
eg1 (T foo bar) b = T (foo, b) (uncurry bar)

But how can I do this with lenses? The following doesn't work with an occurs check:

eg :: T a (b -> c) -> b -> T (a, b) c
eg t b = t & foo %~ (, b) & bar %~ uncurry

There are a few odd things going on here. First, note that you can't make a lens for the `a` in `a -> b`. Second note that you can't make a lens for `Tuple a = Tuple a a`, but you can make a *traversal*. — J. Abrahamson, Sep 28 '15 at 19:09
@J.Abrahamson can you expand? What would the `Tuple a = Tuple a a` traversal be? — user2141650, Sep 29 '15 at 11:45
Traversals are like lenses except that they "focus on" 0 or more "spots". So you can write a traversal which focuses on each half of a homogenous Tuple. — J. Abrahamson, Sep 29 '15 at 12:11
@J.Abrahamson but in this case one `a` is in positive and one in negative position. — user2141650, Sep 29 '15 at 12:15
Yeah, and you simple cannot write a lens over a type in a negative position. There's no "there" to be focused on. — J. Abrahamson, Sep 29 '15 at 12:21

dfeuer · Accepted Answer · 2015-09-29T15:30:45.387

6

You can't do this using the automatically generated lenses for T. If you want to stretch things a bit, you can first define

data T' a b c = T' { _foo' :: c, _bar' :: a -> b}

tt :: Iso (T a b) (T a' b') (T' a b a) (T' a' b' a')
tt = dimap (\(T x g) -> T' x g) (fmap (\(T' x g) -> T x g))

Then you can (automatically) build type-changing lenses for T' and use tt to use them to modify values of type T a b through the isomorphism.

For example, rearranging the arguments a bit, you can write

eg :: b -> T a (b -> c) -> T (a, b) c
eg b = over tt $ (foo' %~ (,b)) . (bar' %~ uncurry)

Another approach that will likely be better if you don't need to fuss around with T too much is to define it as a newtype around T':

newtype T a b = T { getT :: T' a b a }

Then you can skip the Iso and just compose things. Rearranging the arguments the same way,

eg' :: b -> T a (b -> c) -> T (a, b) c
eg' b = T . (foo' %~ (,b)) . (bar' %~ uncurry) . getT

edited Sep 29 '15 at 15:30

answered Sep 27 '15 at 18:19

dfeuer

48,079
5
63
167

1

`over` can be used directly in lieu of `from` bracketing: `supply y = over tt (\(T' x f) -> T' (x, y) (uncurry f))` – duplode Sep 27 '15 at 18:24
@duplode, actually, I can't seem to make that work at all. I've backed off to the bracketing approach, but if you can show how to do it better, I'm all ears. – dfeuer Sep 28 '15 at 05:09
1

It seems the only issue is that `tt` should be `Iso (T a b) (T a' b') (T' a b a) (T' a' b' a')`; that is, `a` should be allowed to change as well. That should be enough to allow you to define `eg` with a single `over` then. – duplode Sep 28 '15 at 11:30
@duplode, at last! I also worked in the lensy modification to `T'`, which was the actual purpose of setting up that `Iso`. – dfeuer Sep 28 '15 at 14:48

Lenses with interdependent (simultaneous) updates

1 Answers1