This is the first post in a sequence of write-up about my study of advanced Haskell concepts. As mentioned in the intro to this sequence, this post does not pretend to be a tutorial, merely an exploration of the subject with many explanations.

Intro

My first couple of stops on the road to Haskell proficiency are the most important typeclasses. This includes the infamous Monad, the unknown Applicative, and the subject of this post: Functor. But before detailing the latter, let's refresh our definition of a Haskell typeclass.

What's a typeclass?

One of Haskell's selling points is its strong type system. We might even say the focus on functional purity stems from the want for powerful type systems. Now, using strong types in a naive way creates massive redundancy: each function would have to be implemented for all the different types it works on. Of course, there will be some implementation to be done -- but the less the better.

Here, genericity comes to the rescue. We use generic types instead of concrete ones to write functions only once -- for the generic type. But this brings another set of problems: with completely generic types, we can't do anything. That's because a type tells us what we can do with its values: you can ask if an int is even or odd, but that doesn't make sense for a bool or a float. For example, a function of type

f :: a -> a

can only be the identity function. Why? Because I don't know anything about values of type a. Notably, I don't know how to build one. So when I need to return a value of type a, and I got one in input, my only option is to give it back.

Typeclasses are a clean way to constrain genericity, so that we can implement non trivial functions on generic types. Formally, a typeclass is defined by a set of functions:

class OurTypeclass a where
  f1 :: a -> [a]
  f2 :: a -> a -> Bool

An instance of this typeclass for a concrete type is an implementation of these functions.

instance OurTypeclass Bool where
  f1 x = [x]
  f2 x y = x

Then this instance gives us the ability to call f1 and f2 on values of type Bool. Which means we can define a generic function on any type with an instance of OurTypeclass, and use f1 and f2 in this function.

f :: (OurTypeclass a) => a -> a -> [a]
f x y = filter (f2 y) (f1 x)

The more types with instances of OurTypeclass, the most useful the abstraction becomes.

Another aspect of

...

Through the Haskell Jungle