Portability  Rank2Types 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Safe Haskell  SafeInferred 
 type Iso s t a b = forall k f. (Isomorphic k, Functor f) => k (a > f b) (s > f t)
 iso :: (Isomorphic k, Functor f) => (s > a) > (a > s) > k (a > f a) (s > f s)
 isos :: (Isomorphic k, Functor f) => (s > a) > (a > s) > (t > b) > (b > t) > k (a > f b) (s > f t)
 ala :: Simple Iso s a > ((s > a) > e > a) > e > s
 auf :: Simple Iso s a > ((b > a) > e > a) > (b > s) > e > s
 under :: Isomorphism (a > Mutator b) (s > Mutator t) > (s > t) > a > b
 from :: Isomorphic k => Isomorphism a b > k b a
 via :: Isomorphic k => Isomorphism a b > k a b
 data Isomorphism a b = Isomorphism (a > b) (b > a)
 class Category k => Isomorphic k where
 isomorphic :: (a > b) > (b > a) > k a b
 isomap :: ((a > b) > c > d) > ((b > a) > d > c) > k a b > k c d
 _const :: Iso a b (Const a c) (Const b d)
 identity :: Iso a b (Identity a) (Identity b)
 simple :: Iso a b a b
 newtype ReifiedIso s t a b = ReifyIso {
 reflectIso :: Iso s t a b
 type SimpleIso s a = Iso s s a a
 type SimpleReifiedIso s a = ReifiedIso s s a a
Isomorphism Lenses
type Iso s t a b = forall k f. (Isomorphic k, Functor f) => k (a > f b) (s > f t)Source
Isomorphism 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
)
typeIso
s t a b = forall k f. (Isomorphic
k,Functor
f) =>Overloaded
k f s t a b
iso :: (Isomorphic k, Functor f) => (s > a) > (a > s) > k (a > f a) (s > f s)Source
isos :: (Isomorphic k, Functor f) => (s > a) > (a > s) > (t > b) > (b > t) > k (a > f b) (s > f t)Source
ala :: Simple Iso s a > ((s > a) > e > a) > e > sSource
Based on ala
from Conor McBride's work on Epigram.
>>>
:m + Data.Monoid.Lens Data.Foldable
>>>
ala _sum foldMap [1,2,3,4]
10
auf :: Simple Iso s a > ((b > a) > e > a) > (b > s) > e > sSource
Based on ala'
from Conor McBride's work on Epigram.
Mnemonically, the German auf plays a similar role to à la, and the combinator
is ala
with an extra function argument.
under :: Isomorphism (a > Mutator b) (s > Mutator t) > (s > t) > a > bSource
Primitive isomorphisms
from :: Isomorphic k => Isomorphism a b > k b aSource
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
.
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.
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.
Common Isomorphisms
Storing Isomorphisms
newtype ReifiedIso s t a b Source
Useful for storing isomorphisms in containers.
ReifyIso  

Simplicity
type SimpleReifiedIso s a = ReifiedIso s s a aSource
typeSimpleReifiedIso
=Simple
ReifiedIso