Think in terms of datatypes. In Haskell for example you can think of two data types to be isomorphic, if there exists a pair of functions that transform data between them in a unique way. The following three types are isomorphic to each other:

data Type1 a = Ax | Ay a
data Type2 a = Blah a | Blubb
data Maybe a = Just a | Nothing

You can think of the functions that transform between them as isomorphisms. This fits with the categorical idea of isomorphism. If between Type1 and Type2 there exist two functions f and g with f . g = g . f = id, then the two functions are isomorphisms between those two types (objects).

An isomorphism u :: a -> b is a function that has an inverse, i.e. another function v :: b -> a such that the relationships

u . v = id
v . u = id

are satisfied. You say that two types are isomorphic if there is an isomorphism between them. This essentially means that you can consider them to be the same type - anything that you can do with one, you can do with the other.

Isomorphism of functions

The two function types

(a,b) -> c
a -> b -> c

are isomorphic, since we can write

u :: ((a,b) -> c) -> a -> b -> c
u f = \x y -> f (x,y)


v :: (a -> b -> c) -> (a,b) -> c
v g = \(x,y) -> g x y

You can check that u . v and v . u are both id. In fact, the functions u and v are better known by the names curry and uncurry.

Isomorphism and Newtypes

We exploit isomorphism whenever we use a newtype declaration. For example, the underlying type of the state monad is s -> (a,s) which can be a little confusing to think about. By using a newtype declaration:

newtype State s a = State { runState :: s -> (a,s) }

we generate a new type State s a which is isomorphic to s -> (a,s) and which makes it clear when we use it, we are thinking about functions that have modifiable state. We also get a convenient constructor State and a getter runState for the new type.

Monads and Comonads

For a more advanced viewpoint, consider the isomorphism using curry and uncurry that I used above. The Reader r a type has the newtype declaration

newType Reader r a = Reader { runReader :: r -> a }

In the context of monads, a function f producing a reader therefore has the type signature

f :: a -> Reader r b

which is equivalent to

f :: a -> r -> b

which is one half of the curry/uncurry isomorphism. We can also define the CoReader r a type:

newtype CoReader r a = CoReader { runCoReader :: (a,r) }

which can be made into a comonad. There we have a function cobind, or =>> which takes a function that takes a coreader and produces a raw type:

g :: CoReader r a -> b

which is isomorphic to

g :: (a,r) -> b

But we already saw that a -> r -> b and (a,r) -> b are isomorphic, which gives us a nontrivial fact: the reader monad (with monadic bind) and the coreader comonad (with comonadic cobind) are isomorphic as well! In particular, they can both be used for the same purpose - that of providing a global environment that is threaded through every function call.

I take a little issue with the upvoted answer for isomorphism, as the category theory definition of isomorphism says nothing about objects. To see why, let's review the definition.

Definition

An isomorphism is a pair of morphisms (i.e. functions), f and g, such that:

f . g = id
g . f = id

These morphisms are then called "iso"morphisms. A lot of people don't catch that the "morphism" in isomorphism refers to the function and not the object. However, you would say that the objects they connect are "isomorphic", which is what the other answer is describing.

Notice that the definition of isomorphism does not say what (.), id, or = must be. The only requirement is that, whatever they are, they also satisfy the category laws:

f . id = f
id . f = f
(f . g) . h = f . (g . h)

Composition (i.e. (.)) joins two morphisms into one morphism and id denotes some sort of "identity" transition. This means that if our isomorphisms cancel out to the identity morphism id, then you can think of them as inverses of each other.

For the specific case where the morphisms are functions, then id is defined as the identity function:

id x = x

... and composition is defined as:

(f . g) x = f (g x)

... and two functions are isomorphisms if they cancel out to the identity function id when you compose them.

Morphisms versus objects

However, there are multiple ways two objects could be isomorphic. For example, given the following two types:

data T1 = A | B
data T2 = C | D

There are two isomorphisms between them:

f1 t1 = case t1 of
A -> C
B -> D
g1 t2 = case t2 of
C -> A
D -> B


(f1 . g1) t2 = case t2 of
C -> C
D -> D
(f1 . g1) t2 = t2
f1 . g1 = id :: T2 -> T2


(g1 . f1) t1 = case t1 of
A -> A
B -> B
(g1 . f1) t1 = t1
g1 . f1 = id :: T1 -> T1


f2 t1 = case t1 of
A -> D
B -> C
g2 t2 = case t2 of
C -> B
D -> A


f2 . g2 = id :: T2 -> T2
g2 . f2 = id :: T1 -> T1

So that's why it's better to describe the isomorphism in terms of the specific functions relating the two objects rather than the two objects, since there may not necessarily be a unique pair of functions between two objects that satisfy the isomorphism laws.

Also, note that it is not sufficient for the functions to be invertible. For example, the following function pairs are not isomorphisms:

f1 . g2 :: T2 -> T2
f2 . g1 :: T2 -> T2

Even though no information is lost when you compose f1 . g2, you don't return back to your original state, even if the final state has the same type.

Also, isomorphisms don't have to be between concrete data types. Here's an example of two canonical isomorphisms are not between concrete algebraic data types and instead simply relate functions: curry and uncurry:

curry . uncurry = id :: (a -> b -> c) -> (a -> b -> c)
uncurry . curry = id :: ((a, b) -> c) -> ((a, b) -> c)

Uses for Isomorphisms

Church Encoding

One use of isomorphisms is to Church-encode data types as functions. For example, Bool is isomorphic to forall a . a -> a -> a:

f :: Bool -> (forall a . a -> a -> a)
f True  = \a b -> a
f False = \a b -> b


g :: (forall a . a -> a -> a) -> Bool
g b = b True False

Verify that f . g = id and g . f = id.

The benefit of Church encoding data types is that they sometimes run faster (because Church-encoding is continuation-passing style) and they can be implemented in languages that don't even have language support for algebraic data types at all.

Translating Implementations

Sometimes one tries to compare one library's implementation of some feature to another library's implementation, and if you can prove that they are isomorphic, then you can prove that they are equally powerful. Also, the isomorphisms describe how to translate one library into the other.

For example, there are two approaches that provide the ability to define a monad from a functor's signature. One is the free monad, provided by the free package and the other is operational semantics, provided by the operational package.

If you look at the two core data types, they look different, especially their second constructors:

-- modified from the original to not be a monad transformer
data Program instr a where
Lift   :: a -> Program instr a
Bind   :: Program instr b -> (b -> Program instr a) -> Program instr a
Instr  :: instr a -> Program instr a


data Free f r = Pure r | Free (f (Free f r))

... but they are actually isomorphic! That means that both approaches are equally powerful and any code written in one approach can be translated mechanically into the other approach using the isomorphisms.

Isomorphisms that are not functions

Also, isomorphisms are not limited to functions. They are actually defined for any Category and Haskell has lots of categories. This is why it's more useful to think in terms of morphisms rather than data types.

For example, the Lens type (from data-lens) forms a category where you can compose lenses and have an identity lens. So using our above data type, we can define two lenses that are isomorphisms:

lens1 = iso f1 g1 :: Lens T1 T2
lens2 = iso g1 f1 :: Lens T2 T1


lens1 . lens2 = id :: Lens T1 T1
lens2 . lens1 = id :: Lens T2 T2

Note that there are two isomorphisms in play. One is the isomorphism that is used to build each lens (i.e. f1 and g1) (and that's also why that construction function is called iso), and then the lenses themselves are also isomorphisms. Note that in the above formulation, the composition (.) used is not function composition but rather lens composition, and the id is not the identity function, but instead is the identity lens:

id = iso id id

Which means that if we compose our two lenses, the result should be indistinguishable from that identity lens.