Control.Lens.Classes

Getters

class Functor 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.

Methods

coerce :: f a -> f b

Replace the phantom type argument.

Instances

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

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

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

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

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

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

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

Functor (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 :: m r -> f a

ineffective :: f a -> m r

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)

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)

Isomorphisms

class Category k => Isomorphic k where

Used to provide overloading of isomorphism application

An instance of Isomorphic is a Category with a canonical mapping to it from the category of isomorphisms over Haskell types.

Methods

iso :: Functor f => (s -> a) -> (b -> t) -> k (a -> f b) (s -> f t)

Build a simple isomorphism from a pair of inverse functions

 view (iso f g) ≡ f
 view (from (iso f g)) ≡ g
 set (iso f g) h ≡ g . h . f
 set (from (iso f g)) h ≡ f . h . g

Instances

Isomorphic (->)

Isomorphic Isoid

Isomorphic Prismoid

Prisms

class Isomorphic k => Prismatic k where

Used to provide overloading of prisms.

An instance of Prismatic is a Category with a canonical mapping to it from the category of embedding-projection pairs over Haskell types.

Methods

prism :: Applicative f => (b -> t) -> (s -> Either t a) -> k (a -> f b) (s -> f t)

Build a Prism.

Either t a is used instead of Maybe a to permit the types of s and t to differ.

Instances

Prismatic (->)

Prismatic Prismoid

Indexable

class Indexable i k where

This class permits overloading of function application for things that also admit a notion of a key or index.

Methods

indexed :: ((i -> a) -> b) -> k a b

Build a function from an Indexed function

Instances

Indexable i (->)

~ * i j => Indexable i (Indexed j)

Using an equality witness to avoid potential overlapping instances and aid dispatch.