Functional lenses

by

A lens consists of two functions, a getter and a setter:

data Lens a b = Lens { getter :: a -> b, setter :: b -> a -> a }

For example, we might have lenses for the first and second parts of a pair:

fstLens :: Lens (a, b) a
fstLens = Lens fst $ \x (a, b) -> (x, b)

sndLens :: Lens (a, b) b
sndLens = Lens snd $ \x (a, b) -> (a, x)

The real convenience of lenses is that they compose:

compose :: Lens b c -> Lens a b -> Lens a c
compose f g = Lens (getter f . getter g) $
                   \c a -> setter g (setter f c (getter g a)) a

And they mechanically convert to State transitions:

lensGet :: MonadState s m => Lens s a -> m a
lensGet = gets . getter

lensSet :: MonadState s m => Lens s b -> b -> m ()
lensSet f = modify . setter f

lensMod :: MonadState s m => Lens s b -> (b -> b) -> m ()
lensMod f g = modify $ setter f =<< g . getter f

(+=) :: (MonadState s m, Num b) => Lens s b -> b -> m ()
f += x = lensMod f (+ x)

More Related Contents:

  1. Haskell: moving image on horizontal line
  2. What is a monad?
  3. Getting started with Haskell
  4. What does (f .) . g mean in Haskell?
  5. Is there a Haskell idiom for updating a nested data structure?
  6. How do you represent a graph in Haskell?
  7. What are paramorphisms?
  8. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  9. How do functors work in haskell?
  10. Large-scale design in Haskell? [closed]
  11. How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?
  12. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  13. Applicative functor evaluation is not clear to me
  14. Ordering of parameters to make use of currying
  15. Why is lazy evaluation useful?
  16. Pattern matching identical values
  17. What is a monad?
  18. How to use (->) instances of Monad and confusion about (->)
  19. How to increment a variable in functional programming?
  20. What part of Hindley-Milner do you not understand?
  21. Why are side-effects modeled as monads in Haskell?
  22. Abusing the algebra of algebraic data types – why does this work?
  23. Iterate over all pair combinations without repetition in Haskell
  24. What’s the status of multicore programming in Haskell?
  25. What does “pure” mean in “pure functional language”?
  26. Implement zip using foldr
  27. How to enumerate a recursive datatype in Haskell?
  28. Why does OCaml sometimes require eta expansion?
  29. How Monads are considered pure?
  30. Explanation of “tying the knot”

Leave a Comment