lens-2.5: Lenses, Folds and Traversals

Portability Rank2Types provisional Edward Kmett Safe-Infered

Control.Lens.Iso

Description

Synopsis

# Isomorphism Lenses

type Iso a b c d = forall k f. (Isomorphic k, Functor f) => k (c -> f d) (a -> f b)Source

Isomorphim families can be composed with other lenses using either (`.`) and `id` from the Prelude or from Control.Category. However, if you compose them with each other using (`.`) from the Prelude, they will be dumbed down to a mere `Lens`.

``` import Control.Category
import Prelude hiding ((.),id)
```
`type Iso a b c d = forall k f. (`Isomorphic` k, `Functor` f) => `Overloaded` k f a b c d`

iso :: (Isomorphic k, Functor f) => (a -> b) -> (b -> a) -> k (b -> f b) (a -> f a)Source

Build a simple isomorphism from a pair of inverse functions

``` `view` (`iso` f g) = f
`view` (`from` (`iso` f g)) = g
`set` (`isos` f g) h = g . h . f
`set` (`from` (`iso` f g')) h = f . h . g
```
`iso :: (a -> b) -> (b -> a) -> `Simple` `Iso` a b`

isos :: (Isomorphic k, Functor f) => (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> k (c -> f d) (a -> f b)Source

Build an isomorphism family from two pairs of inverse functions

``` `view` (`isos` ac ca bd db) = ac
`view` (`from` (`isos` ac ca bd db)) = ca
`set` (`isos` ac ca bd db) cd = db . cd . ac
`set` (`from` (`isos` ac ca bd db')) ab = bd . ab . ca
```
`isos :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> `Iso` a b c d`

au :: Simple Iso a b -> ((a -> b) -> c -> b) -> c -> aSource

Based on `ala` from Conor McBride's work on Epigram.

Mnemonically, au is a French contraction of à le.

````>>> ````:m + Control.Lens Data.Monoid.Lens Data.Foldable
````>>> ````au _sum foldMap [1,2,3,4]
```10
```

auf :: Simple Iso a b -> ((d -> b) -> c -> b) -> (d -> a) -> c -> aSource

Based on `ala'` from Conor McBride's work on Epigram.

Mnemonically, the German auf plays a similar role to à la, and the combinator is au with an extra function argument.

under :: Isomorphism (c -> Mutator d) (a -> Mutator b) -> (a -> b) -> c -> dSource

The opposite of working `over` a Setter is working `under` an Isomorphism.

``under` = `over` . `from``
``under` :: Iso a b c d -> (a -> b) -> (c -> d)`

# Primitive isomorphisms

from :: Isomorphic k => Isomorphism a b -> k b aSource

Invert an isomorphism.

Note to compose an isomorphism and receive an isomorphism in turn you'll need to use `Category`

``` from (from l) = l
```

If you imported `.` from `Control.Category`, then:

``` from l . from r = from (r . l)
```

via :: Isomorphic k => Isomorphism a b -> k a bSource

Convert from an `Isomorphism` back to any `Isomorphic` value.

This is useful when you need to store an isomoprhism as a data type inside a container and later reconstitute it as an overloaded function.

data Isomorphism a b Source

A concrete data type for isomorphisms.

This lets you place an isomorphism inside a container without using `ImpredicativeTypes`.

Constructors

 Isomorphism (a -> b) (b -> a)

class Category k => Isomorphic k whereSource

Used to provide overloading of isomorphism application

This is a `Category` with a canonical mapping to it from the category of isomorphisms over Haskell types.

Methods

isomorphic :: (a -> b) -> (b -> a) -> k a bSource

Build this morphism out of an isomorphism

The intention is that by using `isomorphic`, you can supply both halves of an isomorphism, but k can be instantiated to `(->)`, so you can freely use the resulting isomorphism as a function.

isomap :: ((a -> b) -> c -> d) -> ((b -> a) -> d -> c) -> k a b -> k c dSource

Map a morphism in the target category using an isomorphism between morphisms in Hask.

Instances

 Isomorphic (->) Isomorphic Isomorphism

## Common Isomorphisms

_const :: Iso a b (Const a c) (Const b d)Source

This isomorphism can be used to wrap or unwrap a value in `Const`

``` x `^.` `_const` = `Const` x
`Const` x `^.` `from` `_const` = x
```

identity :: Iso a b (Identity a) (Identity b)Source

This isomorphism can be used to wrap or unwrap a value in `Identity`.

``` x^.identity = `Identity` x
`Identity` x `^.` `from` `identity` = x
```

# Storing Isomorphisms

newtype ReifiedIso a b c d Source

Useful for storing isomorphisms in containers.

Constructors

 ReifyIso FieldsreflectIso :: Iso a b c d

# Simplicity

type SimpleIso a b = Iso a a b bSource

`type SimpleIso = `Simple` `Iso``

type SimpleReifiedIso a b = ReifiedIso a a b bSource

`type SimpleReifiedIso = `Simple` `ReifiedIso``