# The lens package

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

*Getter*

A ` Getter a b c d` is just any function

`(a -> c)`, which we've flipped into continuation passing style,

`forall r. (c -> r) -> a -> r`and decorated with

`Const`to obtain

type Getter a b c d = forall r. (c -> Const r d) -> a -> Const r b

Everything you can do with a function, you can do with a `Getter`, but note that because of the
continuation passing style (.) composes them in the opposite order.

Since it is only a function, every `Getter` obviously only retrieves a single value for a given
input.

*Fold*

A ` Fold a b c d` is a generalization of something

`Foldable`. It allows you to extract multiple results from a container. A

`Foldable`container can be characterized by the behavior of

`foldMap :: (Foldable t, Monoid m) => (c -> m) -> t c -> m`. Since we want to be able to work with monomorphic containers, we generalize this signature to

`forall m.`, and then decorate it with

`Monoid`m => (c -> m) -> a -> m`Const`to obtain

type Fold a b c d = forall m. Monoid m => (c -> Const m d) -> a -> Const m b

Every `Getter` is a valid `Fold` that simply doesn't use the `Monoid` it is passed.

Everything you can do with a `Foldable` container, you can with with a `Fold` and there are
combinators that generalize the usual `Foldable` operations in `Control.Lens`.

*Traversal*

A ` Traversal a b c d` is a generalization of

`traverse`from

`Traversable`. It allows you to traverse over a structure and change out its contents with monadic or applicative side-effects. Starting from

`, we monomorphize the contents and result to obtain`

`traverse`:: (`Traversable`t,`Applicative`f) => (c -> f d) -> t c -> f (t d)type Traversal a b c d = forall f. Applicative f => (c -> f d) -> a -> f b

Every `Traversal` can be used as a valid `Fold`, because given a `Monoid` `m`, we have an `Applicative` for `( Const m)`.
Everything you can do with a

`Traversable`container, you can with with a

`Traversal`, and there are combinators that generalize the usual

`Traversable`operations in

`Control.Lens`.

*Setter*

A ` Setter a b c d` is a generalization of

`fmap`from

`Functor`. It allows you to map into a structure and change out the contents, but it isn't strong enough to allow you to enumerate those contents. Starting with

`fmap ::`we monomorphize the type to obtain

`Functor`f => (c -> d) -> f c -> f d`(c -> d) -> a -> b`and then decorate it with

`Identity`to obtain

type Setter a b c d = (c -> Identity d) -> a -> Identity b

Every `Traversal` is a valid `Setter`, since `Identity` is `Applicative`.

Everything you can do with a `Functor`, you can do with a `Setter`, and there are combinators that
generalize the usual `Functor` operations in `Control.Lens`.

*Lens*

A ` Lens a b c d` is a purely functional reference.

While a `Traversal` was a valid `Fold`, it wasn't a valid `Getter`. To make the `Applicative`
for `Const` it required a `Monoid` for the argument we passed it, which a `Getter` doesn't recieve.

However, the instance of `Functor` for `Const` requires no such thing. If we weaken the type
requirement from `Applicative` to `Functor` for `Traversal`, we obtain

type Lens a b c d = forall f. Functor f => (c -> f d) -> a -> f b

Every `Lens` is a valid `Setter`, choosing `f` = `Identity`.

Every `Lens` is a valid `Fold` that doesn't use the `Monoid` it is passed.

Every `Lens` is a valid `Traversal` that only uses the `Functor` part of the `Applicative` it is supplied.

Every `Lens` is a valid `Getter`, choosing `f` = `Const` `r` for an appropriate `r`

Since every `Lens` is a valid `Getter` it follows that it must view exactly one element in the structure.

The lens laws follow from this property and the desire for it to act like a `Functor` when used as a `Setter`.

*Composition*

Note that all of these types are type aliases, and you can compose these lenses with mere function compositon.

This is a generalization of the well-known trick for `(.).(.)` or `fmap.fmap`, and their less well-known cousins
`foldMap.foldMap` `traverse.traverse`. It follows because each one is a function between values of type `(x -> f y)`
and the composition takes the intersection of supplied functionality for you automatically!

*Lens Families*

For a longer description of why you should care about lenses, and an overview of why we use 4 parameters a, b, c, and d instead of just 2, see http://comonad.com/reader/2012/mirrored-lenses/.

Sometimes you won't need the flexibility those extra parameters afford you and you can use

type Simple f a b = f a a b b

to describe a `Simple` `Lens`, `Simple` `Traversal` or `Simple` `Setter`.

*Avoiding Dependencies*

Note: If you merely want your library to *provide* lenses you may not
have to actually import *any* lens library at all. For, say, a
` Simple Lens Bar Foo`, just export a function with the signature:

foo :: Functor f => (Foo -> f Foo) -> Bar -> f Bar

and then you can compose it with other lenses using nothing more than `(.)` from the Prelude.

*Deriving Lenses*

You can derive lenses automatically for many data types using `Control.Lens.TH`, and if a
container is fully characterized by its lenses, you can use `Control.Lens.Representable` to
automatically derive `Functor`, `Applicative`, `Monad`, and `Derivable`.

- No changelog available

## Properties

## Modules

*Control**Data**Array**Bits**ByteString**Complex**Dynamic**IntMap**IntSet**Map**Sequence**Set**Text**Tree*

[Index]

## Downloads

- lens-1.1.tar.gz [browse] (Cabal source package)
- Package description (included in the package)

#### Maintainers' corner

For package maintainers and hackage trustees