Documentation

A natural transformation from f to g.

The type of an isomorphism between two functors. f <~> g means that f and g are isomorphic to each other.

We can effectively use an f <~> g with:

viewF   :: (f <~> g) -> f a -> g a
reviewF :: (f <~> g) -> g a -> a a

Use viewF to extract the "f to g" function, and reviewF to extract the "g to f" function. Reviewing and viewing the same value (or vice versa) leaves the value unchanged.

One nice thing is that we can compose isomorphisms using . from Prelude:

(.) :: f <~> g
    -> g <~> h
    -> f <~> h

Another nice thing about this representation is that we have the "identity" isomorphism by using id from Prelude.

id :: f <~> g

As a convention, most isomorphisms have form "X-ing", where the forwards function is "ing". For example, we have:

splittingSF :: Monoidal t => SF t a <~> t f (MF t f)
splitSF     :: Monoidal t => SF t a  ~> t f (MF t f)

Create an f <~> g by providing both legs of the isomorphism (the f a -> g a and the g a -> f a.

Use a <~> by retrieving the "forward" function:

viewF   :: (f ~ g) -> f a -> g a

Use a <~> by retrieving the "backwards" function:

viewF   :: (f ~ g) -> f a -> g a

Lift a function g a ~> g a to be a function f a -> f a, given an isomorphism between the two.

One neat thing is that overF i id == id.

Reverse an isomorphism.

viewF   (fromF i) == reviewF i
reviewF (fromF i) == viewF i

Profunctor that allows us to implement fromF.