# Contravariants

###
Brian Berns
*Updated on *
・1 min read

Normal functors in Haskell are pretty easy to understand:

```
class Functor f where
fmap :: (a -> b) -> f a -> f b
```

This just says that if you know how to convert an `a`

into a `b`

, then you can also convert a functor of `a`

into a functor of `b`

. For example, `String.length`

is a `String -> Int`

function, so it can be used to convert a list of strings into a list of integers: `[String] -> [Int]`

. This sort of garden-variety functor is called "covariant".

Contravariant functors look similar, but are used to preprocess input before it reaches a function:

```
-- like a normal functor, but "f b" and "f a" are reversed
class Contravariant f where
contramap :: (a -> b) -> f b -> f a
```

`f b`

and `f a`

are contravariants, but you can think of them as functions that take a `b`

and an `a`

as input, respectively:

```
-- contravariant instance for raw functions
contramap :: (a -> b) -> (b -> x) -> (a -> x)
```

This says that if you know how to convert an `a`

into a `b`

, and you have a function that takes a `b`

as input, then you can create a function that takes an `a`

as input instead. Easy peasy.

Now that you understand covariance and contravariance, you can combine them to get a profunctor.