Functors – Haskell

In Haskell, functors are a key concept in the functional programming paradigm that enable you to apply a function to values inside a container-like structure without altering the structure itself. Functors provide a way to map over data structures in a consistent and generalized way. Understanding functors is crucial because they allow you to write more modular and reusable code that can work with any container-like type.

This article will explain what functors are in Haskell, how they work, and how you can use them in your programs.

What is a Functor?

A functor is a type class in Haskell that represents data structures that can be mapped over. The essence of a functor is that it allows you to apply a function to the values inside a container while keeping the container’s structure intact.

The Functor type class is defined as:

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

• fmap is the central function of the Functor type class. It takes a function (a -> b) and a functor f a, and applies the function to the value inside the functor, producing a new functor f b.
• a and b are type variables representing the types inside the container (before and after applying the function).

In simple terms, a functor allows you to “map” a function over data that is wrapped in a context or container (like a list, Maybe, or Either), without changing the structure of that container.

How Functors Work

Consider the following example: a List is a functor. You can apply a function to each element of a list without changing the list itself.

Example with Lists

fmap (*2) [1, 2, 3]  
-- Result: [2, 4, 6]

Here:

• The fmap (*2) applies the function (*2) (multiply by 2) to each element of the list.
• The list structure remains unchanged, but each element is transformed.

The functor f in this case is the list type [], and fmap applies the function to each element inside the list.

Example with Maybe

Another common functor is Maybe, which represents a value that might be present (Just something) or absent (Nothing).

fmap (+1) (Just 5)
-- Result: Just 6

fmap (+1) Nothing
-- Result: Nothing

Here, fmap (+1) applies the function (+1) to the value inside Just 5, resulting in Just 6. However, when applied to Nothing, it returns Nothing, preserving the structure.

Why Functors Are Useful

Functors allow you to generalize operations on container-like data structures. Instead of writing specific code for each type of container, you can write a generic function that works with any functor. This abstraction makes your code more flexible, modular, and reusable.

For example, the following function will work with any functor that implements the Functor typeclass:

incrementAll :: Functor f => f Int -> f Int
incrementAll = fmap (+1)

This function applies (+1) to every element inside any Functor that contains Int values, whether it’s a list, a Maybe, or some other functor.

Functor Laws

For a type to be a valid functor, it must obey two laws that ensure predictable behavior when using fmap. These laws are:

Identity Law: Applying fmap to the identity function (id) should leave the structure unchanged:

fmap id == id

Composition Law: Applying fmap to the composition of two functions should be equivalent to composing the results of applying fmap to each function:

fmap (f . g) == fmap f . fmap g

These laws ensure that fmap behaves consistently and reliably across all functors.

Functor Examples

Let’s explore a few more examples of functors in Haskell.

Example 1: Either

The Either type is a functor, often used to represent computations that can either succeed with a value (Right) or fail with an error (Left).

fmap (+1) (Right 5)
-- Result: Right 6

fmap (+1) (Left "Error")
-- Result: Left "Error"

In this example:

• fmap (+1) applies the function (+1) to the value inside Right 5, resulting in Right 6.
• For Left, the structure is unchanged since there is no value to modify. The result is still Left "Error".

Example 2: Either with a custom error type

data Error = NotFound | BadRequest

fmap (+1) (Right 10)   -- Right 11
fmap (+1) (Left NotFound)  -- Left NotFound

In this case, Either can be used with any type for both the “success” (Right) and “failure” (Left) cases, making it a versatile functor.

Functors in the Real World

Functors are widely used in Haskell’s standard library and beyond. Some practical examples include:

• Lists: As we saw, lists are functors, and you can use fmap to apply a function to each element in the list.
• Maybe: The Maybe type is often used for handling optional values or computations that can fail without throwing exceptions. fmap helps you apply a function to the value inside Just, if it exists.
• Either: The Either type is used for computations that can either return a value (usually on the right) or fail (usually on the left).
• IO: The IO type is also a functor. You can use fmap to transform values inside IO actions.

Explain Functors Like I’m Five Years Old (ELI5)

Imagine you have a box that can hold a toy inside. You can label this box with the type of toy inside, like “LEGO” or “Action Figure.” Now, let’s say you want to paint every toy in the box a different color. You can’t just paint the toy directly because it’s inside the box. But what if you had a magical way to apply the paint to whatever is inside the box without taking it out? This is where functors come in.

In Haskell, a functor is like a “magic box” that can hold things, and it gives you a special tool (called fmap) that lets you apply a function to whatever’s inside the box without changing the box itself.

For example:

• If you have a box labeled Maybe with a toy inside (like Just 5), you can use fmap to apply a function (say, “add 2”) to the toy inside. This results in a new box with Just 7, but the structure of the box stays the same.
• If you have an empty box labeled Nothing, fmap won’t do anything because there’s no toy inside, and you’ll still have Nothing.

In Haskell terms:

• The box (like Maybe, List, Either) is the functor.
• The function inside (fmap) is the “magic brush” that lets you work on what’s inside the box without changing the box itself.

Summary

• A functor is a type class in Haskell that allows you to apply a function to values inside a container-like structure without changing the structure itself.
• fmap is the core function that defines how the transformation should be applied.
• Functors help write more generic, reusable code that works with various container types (e.g., Maybe, List, Either).
• Functors must follow two laws—identity and composition—to ensure consistent behavior.
• They are essential for building modular, functional programs that can easily adapt to different data structures.

Functors are one of the key concepts that make Haskell a powerful functional programming language. Understanding them will enable you to create more flexible, reusable, and elegant code that can handle a wide variety of data types in a consistent way.

💡 Helpful References

LearnYouAHaskell - Functors
https://learnyouahaskell.github.io/making-our-own-types-and-typeclasses.html#the-functor-typeclass

FAQs about Functors in Haskell

1. What is a functor in Haskell?

A functor in Haskell is a type class that represents types you can “map over.” More specifically, a functor is any data structure that implements the Functor type class and supports the fmap function. This allows you to apply a function to each element inside the structure without changing the structure itself.

2. What does fmap do?

fmap is the key function in the Functor type class. It takes a function (a -> b) and a functor f a (a container holding values of type a) and applies the function to each value inside the functor, resulting in a new functor f b.

For example, fmap (+1) (Just 2) would give Just 3.

3. Which types are functors in Haskell?

Common functors include:

• Lists ([]), which allow you to apply a function to each element in a list.
• Maybe, which applies a function if there’s a value (Just x) or does nothing if it’s Nothing.
• Either, which applies a function to the Right value but ignores Left.
• IO, which lets you transform the value inside an IO action.

4. Why are functors useful?

Functors provide a way to apply functions to values inside “containers” in a consistent way. This is especially helpful for writing generic, reusable code. Since many data structures can act as functors, you can use the same functions (fmap, liftM, etc.) to work with them, simplifying code and improving readability.

5. Are all types in Haskell functors?

No, not all types can be functors. A type can only be a functor if it has a “mappable” structure, meaning it needs a way to contain values and apply a function to each of those values. Simple types like Int or Bool are not functors because they don’t hold other values.

6. What’s the difference between fmap and map?

map is a specific function that applies to lists only (map :: (a -> b) -> [a] -> [b]). fmap, on the other hand, is a more general function that works for any functor, not just lists (fmap :: Functor f => (a -> b) -> f a -> f b). You can think of map as a specialized version of fmap that only works with lists.

7. What are the functor laws?

Functors must satisfy two laws to ensure consistent behavior:

1. Identity Law: fmap id == id — Mapping the identity function (id) over a functor should yield the original functor.
2. Composition Law: fmap (f . g) == fmap f . fmap g — Mapping a composed function f . g should be the same as mapping g and then mapping f over the functor.

8. How does functor composition work?

Functor composition refers to applying two functions in sequence using fmap. If you have fmap g to apply the function g, you can follow it with another fmap f to apply f. Thanks to the composition law, you can combine these into fmap (f . g).

9. Can I define my own functor?

Yes! You can create custom data types and make them instances of the Functor type class by implementing fmap. For example:

data Box a = Box a

instance Functor Box where
    fmap f (Box x) = Box (f x)

Here, Box is a simple container type that can hold a value. The fmap implementation applies f to the contents of Box without changing the Box structure.

10. What’s the relationship between functors, applicatives, and monads?

Functors, applicatives, and monads are all type classes that work with container-like structures, but they provide increasing levels of functionality:

• Functors allow you to map over a structure.
• Applicative Functors extend functors, allowing you to apply functions that are themselves inside a functor.
• Monads build on applicatives, providing even more flexibility, particularly the ability to chain computations with >>= (bind).

11. What are higher-kinded types, and why are they necessary for functors?

A higher-kinded type is a type that takes other types as parameters, such as Maybe, [], or IO. Functors need higher-kinded types because the Functor type class requires a type f that can contain other types (f a). Types like Int or Bool don’t fit this pattern because they don’t take another type as a parameter.

12. What happens if I use fmap on Nothing?

If you use fmap on Nothing with Maybe, it returns Nothing without applying the function. This is because Nothing represents an absence of value, so there’s nothing to apply the function to.

13. Can functions themselves be functors?

Yes, functions are also functors! The fmap operation for functions applies a transformation to the function’s output. If fmap f g is called, it returns a new function that applies g first and then f to the result. This is equivalent to function composition (fmap = (.)).