Control.Lens.Classes

Getters

class (Functor f, Trustworthy f) => Gettable f where

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, an instance of Gettable is required to satisfy:

id = fmap f = coerce

Which is equivalent to making a Gettable f an "anyvariant" functor.

Due to the structure of this library, if you built an illegal Gettable instance that defined coerce = undefined, it would be possible to produce code that would unsafeCoerce.

This would violate the promises of SafeHaskell.

That said, the existing instances are all safe. To verify that any additional instances that *you* provide are safe, you must

 import Control.Lens.Unsafe

and provide an instance of Trustworthy for your data type. That module does not make SafeHaskell guarantees, so by doing so you've taken the SafeHaskell proof obligation into your own hands.

Methods

coerce :: f a -> f b

Replace the phantom type argument.

Instances

(Functor (Const r), Trustworthy (Const r)) => Gettable (Const r)

(Functor (Backwards f), Trustworthy (Backwards f), Gettable f) => Gettable (Backwards f)

(Functor (ElementOf f), Trustworthy (ElementOf f), Gettable f) => Gettable (ElementOf f)

(Functor (Accessor r), Trustworthy (Accessor r)) => Gettable (Accessor r)

(Functor (Indexing f), Trustworthy (Indexing f), Gettable f) => Gettable (Indexing f)

(Functor (Compose f g), Trustworthy (Compose f g), Functor f, Gettable g) => Gettable (Compose f g)

(Functor (Effect m r), Trustworthy (Effect m r)) => Gettable (Effect m r)

(Functor (BazaarT a b g), Trustworthy (BazaarT a b g), Gettable g) => Gettable (BazaarT a b g)

(Functor (EffectRWS w st m s), Trustworthy (EffectRWS w st m s)) => Gettable (EffectRWS w st m s)

noEffect :: (Applicative f, Gettable f) => f a

The mempty equivalent for a Gettable Applicative Functor.

Actions

class (Monad m, Gettable f) => Effective m r f | f -> m r where

An Effective Functor ignores its argument and is isomorphic to a monad wrapped around a value.

That said, the monad is possibly rather unrelated to any Applicative structure.

Methods

effective :: Isomorphic k => k (m r) (f a)

Instances

(Monad Identity, Gettable (Accessor r)) => Effective Identity r (Accessor r)

(Gettable (Effect m r), Monad m) => Effective m r (Effect m r)

(Monad m, Gettable (Backwards f), Effective m r f) => Effective m (Dual r) (Backwards f)

ineffective :: Effective m r f => Isomorphic k => k (f a) (m r)

A convenient antonym that is used internally.

Setters

class Applicative f => Settable f where

Anything Settable must be isomorphic to the Identity Functor.

Methods

untainted :: f a -> a

untainted# :: (a -> f b) -> a -> b

tainted# :: (a -> b) -> a -> f b

Instances

Settable Identity

so you can pass our a Setter into combinators from other lens libraries

Settable Mutator

(Applicative (Backwards f), Settable f) => Settable (Backwards f)

backwards

(Applicative (Compose f g), Settable f, Settable g) => Settable (Compose f g)