Control.Lens.Iso

Isomorphisms

class Category k => Isomorphic k where

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 b

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 d

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

Instances

Isomorphic (->)

Isomorphic Isomorphism

data Isomorphism a b

A concrete data type for isomorphisms.

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

Constructors

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

Instances

Typeable2 Isomorphism

Category Isomorphism

Isomorphic Isomorphism

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

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)

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

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

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 b

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.

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

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

type SimpleIso a b = Iso a a b b

type SimpleIso = Simple Iso

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

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)

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

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