消除 Haskell 镜头中的“翻转”

Question

I'm trying to get the hang of lenses. Is there a more idiomatic way to write the following? (placeholders preceded by underscores)

flip (set _lens) _a . fmap _f

To me, the use of flip seems to suggest non-idiomatic code. Is there a better combinator that avoids flip in this situation? Is there a more lens-like way of integrating the fmap?

Answer 1

In this case, you might want to consider writing it pointed

\x -> _a & _lens .~ fmap _f x

which feels much more idiomatic to me.

If you really want it pointfree without flip , you can convert the above to pointfree:

(_a &) . set _lens . fmap _f

(Although technically, since & is equivalent to flip ($) , you're really just hiding the flip .)

Answer 2

I think @DDub has covered the first half of your question. As for a more "lens-like" way of integrating the fmap , this seems to be a special case of a more general problem. If I have a setter:

> (1,"a") & _1 .~ True
(True,"a")

then I think there ought be a combinator that allows me to write:

> (1,"a") & _1 . applying not  .~ True
(False,"a")

This combinator doesn't appear to exist in lens (unless someone else can spot it), but you can define it as:

applying :: Functor f => (a -> b) -> (c -> f a) -> (c -> f b)
applying f = (fmap f .)

or using the Functor instance for (->) r :

applying :: Functor f => (a -> b) -> (c -> f a) -> (c -> f b)
applying = fmap . fmap

This leads to the amusing fact that the setter:

_lens . (fmap . fmap . fmap) _f

combines _lens with application of fmap _f , so the following produce equivalent results:

ex1 = (flip (set _1) ("a","b") . fmap not) $ Just True
ex2 = ("a","b") & _1 . applying (fmap not) .~ Just True
ex3 = ("a","b") & _1 . (fmap . fmap . fmap) not .~ Just True
-- all the above yield: (Just False,"b")

and are sure to amaze your friends.