1 Example:

maybeToList

In the followings, this example will be used to illustrate the notion of natural transformation. If the examples are exaggerated and/or the definitions are incomprehendable, try #External links.

2 Definition

Let , denote categories.

Let be functors.

Let . Let .

Let us define the natural transformation. It associates to each object of a morphism of in the following way (usually, not sets are discussed here, but proper classes, so I do not use term “function” for this mapping):

. We call ηA the component of η at A.

Thus, the following diagram commutes (in ):

2.1 Vertical arrows: sides of objects

… showing how the natural transformation works.

maybeToList ::Maybe a ->[a]

2.1.1 Left: side of X object

maybeToList ::MaybeInt->[Int]

Nothing

[]

Just 0

[0]

Just 1

[1]

2.1.2 Right: side of Y object

maybeToList ::MaybeBool->[Bool]

Nothing

[]

Just True

[True]

Just False

[False]

2.2 Horizontal arrows: sides of functors

even::Int->Bool

2.2.1 Side of Φ functor

fmapeven::MaybeInt->MaybeBool

Nothing

Nothing

Just 0

Just True

Just 1

Just False

2.2.2 Side of Ψ functor

mapeven::[Int]->[Bool]

[]

[]

[0]

[True]

[1]

[False]

2.3 Commutativity of the diagram

both paths span between

MaybeInt->[Bool]

mapeven. maybeToList

maybeToList .fmapeven

Nothing

[]

[]

Just 0

[True]

[True]

Just 1

[False]

[False]

2.4 Remarks

even

has a more general type (

Integral a => a ->Bool

) than described here

Words “side”, “horizontal”, “vertical”, “left”, “right” serve here only to point to the discussed parts of a diagram, thus, they are not part of the scientific terminology.

3 Operations

3.1 Functor and natural transformation

Let us imagine a parser library, which contains functions for parsing a form. There are two kinds of cells:

containing data which are optional (e.g. name of spouse)

containing data which consist of an enumaration of items (e.g. names of acquired languages)

spouse :: Parser (MaybeString)
languages :: Parser [String]

Let us imagine we have any processing (storing, archiving etc.) function which processes lists (or any other reason which forces us to convert our results to list format and exclude any Maybe's). (Perhaps, all this example is unparactical and exaggerated, because in real life we should solve the whole thing in other ways.)

We can convert

Maybe

to list with

maybeToList

But if we want to do something similar with a parser on Maybe's to achieve a parser on list, then

maybeToList

is not enough alone, we must

fmap

it.
E.g. if we want to convert a parser like

spouse

to be of the same type as

languages

:

fmap maybeToList spouse

Let us see the types:
We start with

spouse :: Parser (MaybeString)

Λ(Φ(X))

or using notion of composing functors

(ΛΦ)(X)

We want to achieve

fmap maybeToList spouse :: Parser [String]

Λ(Ψ(X))

(ΛΨ)(X)

thus we can infer

fmap maybeToList :: Parser (Maybe[String])-> Parser [String]

In fact, we have a new “datatype converter”: converting not Maybe's to lists, but parser on Maybe to Parser on list. Let us notate the corresponding natural transformation with Λη:

To each we associate

(Λη)X = Λ(ηX)

3.2 Natural transformation and functor

(ηΔ)X = ηΔ(X)

It can be illustrated by Haskell examples, too. Understanding it is made harder (easier?) by the fact that Haskell's type inference “dissolves” the main point, thus there is no “materialized” manifestation of it.