lens-3.8.7.3: Lenses, Folds and Traversals

Portability | non-portable
Stability | experimental
Maintainer | Edward Kmett <ekmett@gmail.com>
Safe Haskell | Trustworthy

Control.Lens.Internal.Context

Description

Synopsis

- class IndexedFunctor w where
  - ifmap :: (s -> t) -> w a b s -> w a b t
- class IndexedFunctor w => IndexedComonad w where
  - iextract :: w a a t -> t
  - iduplicate :: w a c t -> w a b (w b c t)
  - iextend :: (w b c t -> r) -> w a c t -> w a b r
- class IndexedComonad w => IndexedComonadStore w where
  - ipos :: w a c t -> a
  - ipeek :: c -> w a c t -> t
  - ipeeks :: (a -> c) -> w a c t -> t
  - iseek :: b -> w a c t -> w b c t
  - iseeks :: (a -> b) -> w a c t -> w b c t
  - iexperiment :: Functor f => (b -> f c) -> w b c t -> f t
  - context :: w a b t -> Context a b t
- class Corepresentable p => Sellable p w | w -> p where
  - sell :: p a (w a b b)
- data Context a b t = Context (b -> t) a
- type Context' a = Context a a
- newtype Pretext p a b t = Pretext {
  - runPretext :: forall f. Functor f => p a (f b) -> f t
  }
- type Pretext' p a = Pretext p a a
- newtype PretextT p g a b t = PretextT {
  - runPretextT :: forall f. Functor f => p a (f b) -> f t
  }
- type PretextT' p g a = PretextT p g a a

# Documentation

class IndexedFunctor w where

This is a Bob Atkey -style 2-argument indexed functor.

It exists as a superclass for `IndexedComonad` and expresses the functoriality of an `IndexedComonad` in its third argument.

Methods

ifmap :: (s -> t) -> w a b s -> w a b t

Instances

IndexedFunctor Context |
IndexedFunctor Mafic |
IndexedFunctor (Pretext p) |
IndexedFunctor (Bazaar p) |
IndexedFunctor (Molten i) |
IndexedFunctor (PretextT p g) |
IndexedFunctor (BazaarT p g) |
IndexedFunctor (TakingWhile p f) |

class IndexedFunctor w => IndexedComonad w where

This is a Bob Atkey -style 2-argument indexed comonad.

It exists as a superclass for `IndexedComonad` and expresses the functoriality of an `IndexedComonad` in its third argument.

The notion of indexed monads is covered in more depth in Bob Atkey's Parameterized Notions of Computation http://bentnib.org/paramnotions-jfp.pdf and that construction is dualized here.

Methods

iextract :: w a a t -> t

extract from an indexed comonadic value when the indices match.

iduplicate :: w a c t -> w a b (w b c t)

duplicate an indexed comonadic value splitting the index.

iextend :: (w b c t -> r) -> w a c t -> w a b r

extend a indexed comonadic computation splitting the index.

Instances

IndexedComonad Context |
Conjoined p => IndexedComonad (Pretext p) |
Conjoined p => IndexedComonad (Bazaar p) |
IndexedComonad (Molten i) |
Conjoined p => IndexedComonad (PretextT p g) |
Conjoined p => IndexedComonad (BazaarT p g) |

class IndexedComonad w => IndexedComonadStore w where

This is an indexed analogue to `ComonadStore` for when you are working with an `IndexedComonad`.

Methods

ipos :: w a c t -> a

This is the generalization of `pos` to an indexed comonad store.

ipeek :: c -> w a c t -> t

This is the generalization of `peek` to an indexed comonad store.

ipeeks :: (a -> c) -> w a c t -> t

This is the generalization of `peeks` to an indexed comonad store.

iseek :: b -> w a c t -> w b c t

This is the generalization of `seek` to an indexed comonad store.

iseeks :: (a -> b) -> w a c t -> w b c t

This is the generalization of `seeks` to an indexed comonad store.

iexperiment :: Functor f => (b -> f c) -> w b c t -> f t

This is the generalization of `experiment` to an indexed comonad store.

context :: w a b t -> Context a b t

We can always forget the rest of the structure of `w` and obtain a simpler indexed comonad store model called `Context`.

Instances

IndexedComonadStore Context |
Conjoined p => IndexedComonadStore (Pretext p) |
Conjoined p => IndexedComonadStore (PretextT p g) |

class Corepresentable p => Sellable p w | w -> p where

This is used internally to construct a `Bazaar`, `Context` or `Pretext` from a singleton value.

Methods

sell :: p a (w a b b)

Instances

Sellable (->) Context |
Sellable (->) Mafic |
Corepresentable p => Sellable p (Pretext p) |
Corepresentable p => Sellable p (Bazaar p) |
Corepresentable p => Sellable p (PretextT p g) |
Corepresentable p => Sellable p (BazaarT p g) |
Sellable (Indexed i) (Molten i) |

data Context a b t

The indexed store can be used to characterize a `Lens` and is used by `clone`.

``Context` a b t` is isomorphic to `newtype `Context` a b t = `Context` { runContext :: forall f. `Functor` f => (a -> f b) -> f t }`, and to `exists s. (s, `Lens` s t a b)`.

A `Context` is like a `Lens` that has already been applied to a some structure.

Constructors

Context (b -> t) a |

Instances

IndexedComonadStore Context |
IndexedComonad Context |
IndexedFunctor Context |
Sellable (->) Context |
~ * a b => ComonadStore a (Context a b) |
Functor (Context a b) |
~ * a b => Comonad (Context a b) |

type Context' a = Context a a

    type Context' a s = Context a a s

newtype Pretext p a b t

This is a generalized form of `Context` that can be repeatedly cloned with less impact on its performance, and which permits the use of an arbitrary `Conjoined` `Profunctor`

Constructors

Pretext |

Fields

runPretext :: forall f. Functor f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (Pretext p) |
(~ * a b, Conjoined p) => ComonadStore a (Pretext p a b) |
Conjoined p => IndexedComonadStore (Pretext p) |
Conjoined p => IndexedComonad (Pretext p) |
IndexedFunctor (Pretext p) |
Functor (Pretext p a b) |
(~ * a b, Conjoined p) => Comonad (Pretext p a b) |

type Pretext' p a = Pretext p a a

    type Pretext' p a s = Pretext p a a s

newtype PretextT p g a b t

This is a generalized form of `Context` that can be repeatedly cloned with less impact on its performance, and which permits the use of an arbitrary `Conjoined` `Profunctor`.

The extra phantom `Functor` is used to let us lie and claim a `Gettable` instance under limited circumstances. This is used internally to permit a number of combinators to gracefully degrade when applied to a `Fold`, `Getter` or `Action`.

Constructors

PretextT |

Fields

runPretextT :: forall f. Functor f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (PretextT p g) |
(~ * a b, Conjoined p) => ComonadStore a (PretextT p g a b) |
Conjoined p => IndexedComonadStore (PretextT p g) |
Conjoined p => IndexedComonad (PretextT p g) |
IndexedFunctor (PretextT p g) |
Functor (PretextT p g a b) |
(~ * a b, Conjoined p) => Comonad (PretextT p g a b) |
(Profunctor p, Gettable g) => Gettable (PretextT p g a b) |

type PretextT' p g a = PretextT p g a a

    type PretextT' p g a s = PretextT p g a a s