# lens: Lenses, Folds and Traversals

[ bsd2, data, generics, lenses, library ] [ Propose Tags ]

This package comes "Batteries Included" with many useful lenses for the types commonly used from the Haskell Platform, and with tools for automatically generating lenses and isomorphisms for user-supplied data types.

The combinators in Control.Lens provide a highly generic toolbox for composing families of getters, folds, isomorphisms, traversals, setters and lenses and their indexed variants.

More information on the care and feeding of lenses, including a tutorial and motivation for their types can be found on the lens wiki.

https://github.com/ekmett/lens/wiki

A small game that manages its state using lenses can be found in the example folder.

https://github.com/ekmett/lens/blob/master/examples/Pong.hs

Lenses, Folds and Traversals

The core of this hierarchy looks like:

You can compose any two elements of the hierarchy above using (.) from the Prelude, and you can use any element of the hierarchy as any type it links to above it.

The result is their lowest upper bound in the hierarchy (or an error if that bound doesn't exist).

For instance:

• You can use any Traversal as a Fold or as a Setter.

• The composition of a Traversal and a Getter yields a Fold.

Minimizing Dependencies

If you want to provide lenses and traversals for your own types in your own libraries, then you can do so without incurring a dependency on this (or any other) lens package at all.

e.g. for a data type:

data Foo a = Foo Int Int a

You can define lenses such as

-- bar :: Simple Lens (Foo a) Int
bar :: Functor f => (Int -> f Int) -> Foo a -> f Foo a
bar f (Foo a b c) = fmap (\a' -> Foo a' b c) (f a)
-- baz :: Lens (Foo a) (Foo b) a b
quux :: Functor f => (a -> f b) -> Foo a -> f (Foo b)
quux f (Foo a b c) = fmap (Foo a b) (f c)

without the need to use any type that isn't already defined in the Prelude.

And you can define a traversal of multiple fields with Control.Applicative.Applicative:

-- traverseBarAndBaz :: Simple Traversal (Foo a) Int
traverseBarAndBaz :: Applicative f => (Int -> f Int) -> Foo a -> f (Foo a)
traverseBarAndBaz f (Foo a b c) = Foo <$> f a <*> f b <*> pure c What is provided in this library is a number of stock lenses and traversals for common haskell types, a wide array of combinators for working them, and more exotic functionality, (e.g. getters, setters, indexed folds, isomorphisms). [Skip to Readme] Versions 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0.1, 1.0.2, 1.0.3, 1.1, 1.1.1, 1.2, 1.3, 1.3.1, 1.4, 1.4.1, 1.5, 1.6, 1.7, 1.7.1, 1.8, 1.9, 1.9.1, 2.0, 2.1, 2.2, 2.3, 2.4, 2.4.0.2, 2.5, 2.6, 2.6.1, 2.7, 2.7.0.1, 2.8, 2.9, 3.0, 3.0.1, 3.0.2, 3.0.3, 3.0.4, 3.0.5, 3.0.6, 3.1, 3.2, 3.3, 3.4, 3.5, 3.5.1, 3.6, 3.6.0.1, 3.6.0.2, 3.6.0.3, 3.6.0.4, 3.7, 3.7.0.1, 3.7.0.2, 3.7.1, 3.7.1.1, 3.7.1.2, 3.7.2, 3.7.3, 3.7.4, 3.7.5, 3.7.6, 3.8, 3.8.0.1, 3.8.0.2, 3.8.1, 3.8.2, 3.8.3, 3.8.4, 3.8.5, 3.8.6, 3.8.7, 3.8.7.1, 3.8.7.2, 3.8.7.3, 3.9, 3.9.0.1, 3.9.0.2, 3.9.0.3, 3.9.1, 3.9.2, 3.10, 3.10.0.1, 3.10.1, 3.10.2, 3.10.3, 4.0, 4.0.1, 4.0.2, 4.0.3, 4.0.4, 4.0.5, 4.0.6, 4.0.7, 4.1, 4.1.1, 4.1.2, 4.1.2.1, 4.2, 4.3, 4.3.1, 4.3.2, 4.3.3, 4.4, 4.4.0.1, 4.4.0.2, 4.5, 4.6, 4.6.0.1, 4.7, 4.7.0.1, 4.8, 4.9, 4.9.1, 4.10, 4.11, 4.11.1, 4.12, 4.12.1, 4.12.2, 4.12.3, 4.13, 4.13.1, 4.13.2, 4.13.2.1, 4.14, 4.15, 4.15.1, 4.15.2, 4.15.3, 4.15.4, 4.16, 4.16.1 CHANGELOG.markdown array (>=0.3.0.2 && <0.5), base (>=4.3 && <5), bytestring (>=0.9.1.10 && <0.10), containers (>=0.4.2 && <0.6), ghc-prim, mtl (>=2.1.1 && <2.2), parallel (>=3.1.0.1 && <3.3), template-haskell (>=2.4 && <2.8), text (>=0.11.1.5 && <0.12), transformers (==0.3.*) [details] BSD-3-Clause Copyright (C) 2012 Edward A. Kmett Edward A. Kmett Edward A. Kmett Data, Lenses http://github.com/ekmett/lens/ http://github.com/ekmett/lens/issues head: git clone git://github.com/ekmett/lens.git by EdwardKmett at Wed Aug 15 08:25:59 UTC 2012 Arch:4.15.4, Debian:4.13, Fedora:4.15.4, FreeBSD:4.12.3, LTSHaskell:4.16.1, NixOS:4.16.1, Stackage:4.16.1, openSUSE:4.16.1 249672 total (554 in the last 30 days) 2.75 (votes: 34) [estimated by rule of succession] λ λ λ Docs uploaded by userBuild status unknown Hackage Matrix CI ## Modules [Index] ## Downloads #### Maintainer's Corner For package maintainers and hackage trustees ## Readme for lens-2.3 [back to package description] # Lens: Lenses, Folds, and Traversals This package provides families of lenses, isomorphisms, folds, traversals, getters and setters. An overview of the derivation of these types can be found on the Lens Wiki along with a brief Tutorial. Documentation is available through github or hackage. ## Examples You can read from lenses (or other getters) and they compose in the order an imperative programmer would expect. ghci> :m + Control.Lens ghci> ("hello",("world","!!!"))^._2._1 "world"  You can make getters out of pure functions with to. ghci> ("hello",("world","!!!"))^._2._1.to length 5  You can write to lenses and these writes can change the type of the container. ghci> _1 .~ "hello"$ ((),"world")
("hello","world)


You can let the library automatically derive lenses for fields of your data type

import Control.Lens

data Foo a = Foo { _bar :: Int, _baz :: Int, _quux :: a }
makeLenses ''Foo


This will automatically generate the following lenses:

bar, baz :: Simple Lens (Foo a) Int
quux :: Lens (Foo a) (Foo b) a b


You can also write to setters that target multiple parts of a structure, or their composition with other lenses or setters.

ghci> _1.mapped._2.mapped %~ succ $([(42, "hello")],"world") ([(42, "ifmmp")],"world")  ghci> both *~ 2$ (1,2)
(2,4)


There are combinators for manipulating the current state in a state monad as well

fresh :: MonadState Int m => m Int
fresh = id <+= 1


Anything you know how to do with a Foldable container, you can do with a Fold

ghci> :m + Data.Char Data.Text.Lens
ghci> allOf (folded.text) isLower ["hello"^.packed, "goodbye"^.packed]
True


You can also use this for generic programming:

ghci> :m + GHC.Generics.Lens
ghci> anyOf every (=="world") ("hello",(),[(2::Int,"world")])
True


Anything you know how to do with a Traversable you can do with a Traversal.

ghci> mapMOf (traverse._2) (\xs -> length xs <\$ putStrLn xs) [(42,"hello"),(56,"world")]
"hello"
"world"
[(42,5),(56,5)]


Many of the lenses supplied are isomorphisms, that means you can use them directly as a lens:

ghci> let hello = "hello"^.packed
"hello"
ghci> :t hello
hello :: Text


but you can also flip them around and use them as a lens the other way with from

ghci> hello^.from packed.to length
5


You can automatically derive isomorphisms for your own newtypes with makeIso. e.g.

newtype Neither a b = Neither { _nor :: Either a b } deriving (Show)
makeIso ''Neither


will automatically derive

neither :: Iso (Neither a b) (Neither c d) (Either a b) (Either c d)
nor :: Iso (Either a b) (Either c d) (Neither a b) (Neither c d)


such that

from neither = nor
from nor = neither
neither.nor = id
nor.neither = id


There is also a fully operational, but simple game of Pong in the examples/ folder.

## Contact Information

Contributions and bug reports are welcome!

Please feel free to contact me through github or on the #haskell IRC channel on irc.freenode.net.

-Edward Kmett