Portability  Rank2Types 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Safe Haskell  SafeInfered 
A
is just any function Getter
a c(a > c)
, which we've flipped into continuation
passing style, (c > r) > a > r
and decorated with Accessor
to obtain
typeGetting
r a b c d = (c >Accessor
r d) > a >Accessor
r b
If we restrict access to knowledge about the type r
and can work for any d and b, we could get:
typeGetter
a c = forall r b d.Getting
r a b c d
But we actually hide the use of Accessor
behind a class Gettable
to error messages from
type class resolution rather than at unification time, where they are much uglier.
typeGetter
a c = forall f b d.Gettable
f => (c > f d) > a > f 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.
 type Getter a c = forall f b d. Gettable f => (c > f d) > a > f b
 type Getting r a b c d = (c > Accessor r d) > a > Accessor r b
 class Functor f => Gettable f where
 coerce :: f a > f b
 newtype Accessor r a = Accessor {
 runAccessor :: r
 to :: (a > c) > Getter a c
 (^.) :: a > Getting c a b c d > c
 (^$) :: Getting c a b c d > a > c
 view :: Getting c a b c d > a > c
 views :: Getting m a b c d > (c > m) > a > m
 use :: MonadState a m => Getting c a b c d > m c
 uses :: MonadState a m => Getting e a b c d > (c > e) > m e
 query :: MonadReader a m => Getting c a b c d > m c
 queries :: MonadReader a m => Getting e a b c d > (c > e) > m e
Getters
type Getter a c = forall f b d. Gettable f => (c > f d) > a > f bSource
A Getter
describes how to retrieve a single value in a way that can be composed with
other lenslike constructions.
Unlike a Lens
a Getter
is readonly. Since a Getter
cannot be used to write back
there are no lens laws that can be applied to it. In fact, it is isomorphic to an arbitrary function from (a > c)
.
Moreover, a Getter
can be used directly as a Fold
, since it just ignores the Applicative
.
type Getting r a b c d = (c > Accessor r d) > a > Accessor r bSource
Most Getter
combinators are able to be used with both a Getter
or a Fold
in
limited situations, to do so, they need to be monomorphic in what we are going to
extract with Const
. To be compatible with Lens
, Traversal
and Iso
we also
restricted choices of the irrelevant b and d parameters.
If a function accepts a
, then when Getting
m r a b c dr
is a Monoid
, and m
is a
Monad
you can pass a Fold
(or Traversal
), otherwise you can only pass this a
Getter
or Lens
.
class Functor f => Gettable f whereSource
Generalizing Const
so we can apply simple Applicative
transformations to it
and so we can get nicer error messages
A Gettable
Functor
ignores its argument, which it carries solely as a phantom
type parameter.
To ensure this, it is required to satisfy:
id = fmap f = coerce
Used instead of Const
to report
No instance of (Settable
Accessor
)
when the user attempts to misuse a Setter
as a Getter
,
rather than a monolithic unification error.
Accessor  

Building Getters
Combinators for Getters and Folds
(^.) :: a > Getting c a b c d > cSource
View the value pointed to by a Getter
or Lens
or the result of folding over
all the results of a Fold
or Traversal
that points at a monoidal values.
This is the same operation as view
with the arguments flipped.
The fixity and semantics are such that subsequent field accesses can be
performed with (.
)
>>>
:m + Data.Complex Control.Lens
>>>
((0, 1 :+ 2), 3)^._1._2.to magnitude
2.23606797749979
(^.) :: a >Getter
a c > c (^.) ::Monoid
m => a >Fold
a m > m (^.) :: a >Iso
a b c d > c (^.) :: a >Lens
a b c d > c (^.) ::Monoid
m => a >Traversal
a b m d > m
(^$) :: Getting c a b c d > a > cSource
View the value pointed to by a Getter
, Iso
or Lens
or the result of folding over
all the results of a Fold
or Traversal
that points at a monoidal values.
This is the same operation as view
, only infix.
>>>
import Control.Lens
>>>
_2 ^$ (1, "hello")
"hello"
(^$) ::Getter
a c > a > c (^$) ::Monoid
m =>Fold
a m > a > m (^$) ::Iso
a b c d > a > c (^$) ::Lens
a b c d > a > c (^$) ::Monoid
m =>Traversal
a b m d > a > m
view :: Getting c a b c d > a > cSource
View the value pointed to by a Getter
, Iso
or Lens
or the result of folding over
all the results of a Fold
or Traversal
that points at a monoidal values.
It may be useful to think of view
as having these more restrictive signatures:
view
.to
=id
>>>
import Control.Lens
>>>
view _2 (1,"hello")
"hello"
view ::Getter
a c > a > c view ::Monoid
m =>Fold
a m > a > m view ::Iso
a b c d > a > c view ::Lens
a b c d > a > c view ::Monoid
m =>Traversal
a b m d > a > m
views :: Getting m a b c d > (c > m) > a > mSource
View the value of a Getter
, Iso
, Lens
or the result of folding over the
result of mapping the targets of a Fold
or Traversal
.
It may be useful to think of views
as having these more restrictive signatures:
>>>
import Control.Lens
>>>
views _2 length (1,"hello")
5
views ::Getter
a c > (c > d) > a > d views ::Monoid
m =>Fold
a c > (c > m) > a > m views ::Iso
a b c d > (c > d) > a > d views ::Lens
a b c d > (c > d) > a > d views ::Monoid
m =>Traversal
a b c d > (c > m) > a > m
use :: MonadState a m => Getting c a b c d > m cSource
Use the target of a Lens
, Iso
, or Getter
in the current state, or use a
summary of a Fold
or Traversal
that points to a monoidal value.
use ::MonadState
a m =>Getter
a c > m c use :: (MonadState
a m,Monoid
r) =>Fold
a r > m r use ::MonadState
a m =>Iso
a b c d > m c use ::MonadState
a m =>Lens
a b c d > m c use :: (MonadState
a m,Monoid
r) =>Traversal
a b r d > m r
uses :: MonadState a m => Getting e a b c d > (c > e) > m eSource
Use the target of a Lens
, Iso
or Getter
in the current state, or use a
summary of a Fold
or Traversal
that points to a monoidal value.
uses ::MonadState
a m =>Getter
a c > (c > e) > m e uses :: (MonadState
a m,Monoid
r) =>Fold
a c > (c > r) > m r uses ::MonadState
a m =>Lens
a b c d > (c > e) > m e uses ::MonadState
a m =>Iso
a b c d > (c > e) > m e uses :: (MonadState
a m,Monoid
r) =>Traversal
a b c d > (c > r) > m r
query :: MonadReader a m => Getting c a b c d > m cSource
Query the target of a Lens
, Iso
or Getter
in the current state, or use a
summary of a Fold
or Traversal
that points to a monoidal value.
query ::MonadReader
a m =>Getter
a c > m c query :: (MonadReader
a m,Monoid
c) =>Fold
a c > m c query ::MonadReader
a m =>Iso
a b c d > m c query ::MonadReader
a m =>Lens
a b c d > m c query :: (MonadReader
a m,Monoid
c) =>Traversal
a b c d > m c
queries :: MonadReader a m => Getting e a b c d > (c > e) > m eSource
Use the target of a Lens
, Iso
or Getter
in the current state, or use a
summary of a Fold
or Traversal
that points to a monoidal value.
queries ::MonadReader
a m =>Getter
a c > (c > e) > m e queries :: (MonadReader
a m,Monoid
c) =>Fold
a c > (c > e) > m e queries ::MonadReader
a m =>Iso
a b c d > (c > e) > m e queries ::MonadReader
a m =>Lens
a b c d > (c > e) > m e queries :: (MonadReader
a m,Monoid
c) =>Traversal
a b c d > (c > e) > m e