FmapEdit

Fmap is a core operation in functional programming that enables applying a function to every element inside a container-like structure while preserving the overall shape of the structure. It is the canonical way to lift a plain function into the realm of data wrapped in a context, such as a list, an optional value, or an effect. In practice, fmap is the primary interface that powers transformations across a family of types that share a common abstraction known as a Functor.

The concept of fmap sits at the intersection of programming language design and mathematical thinking. It embodies the idea that many data structures can be acted upon uniformly by functions, without the caller needing to know the details of how the data are stored. This separation of concerns makes code more modular and easier to reason about.

Definition and semantics

The general idea of fmap is to map a function over a structure without changing the structure itself. In languages with a type class or interface named Functor, fmap is the operation that performs this lifting.
In many languages, the canonical type signature is something like: fmap :: <a href="/wiki/functor">Functor</a> f => (a -> b) -> f a -> f b. The idea is that, given a function from a to b and a container holding values of type a, fmap yields a container holding values of type b, in the same shape as the original container.
The act of mapping respects the structure. For a list, that means applying the function to each element; for a Maybe/Option-like type, it applies the function to the contained value if present, and leaves Nothing/None untouched; for a function type (a -> r) viewed as a functor in its result type, fmap corresponds to function composition.

Functor laws and guarantees

A robust implementation of fmap adheres to two fundamental laws that keep reasoning about programs predictable:

Identity: fmap id = id. Mapping the identity function over a structure yields the original structure unchanged.
Composition: fmap (f . g) = (fmap f) . (fmap g). Mapping a composition of two functions is equivalent to mapping each function in sequence.

These laws guarantee that fmap behaves in a well-behaved, predictable way, enabling equational reasoning and refactoring with confidence.

Instances and practical usage

Lists: In languages that treat lists as a simple container, lists are a natural instance of a Functor. Mapping a function over a list applies the function to every element. For example, in a language with list syntax, fmap could be used to double every item: fmap (*2) [1,2,3] yields [2,4,6].
Maybe/Option: An optional value is another common instance. fmap applies the function only when a value is present, leaving the empty case untouched. This is a common pattern when dealing with missing data without resorting to explicit null checks.
Either/Result: An error-bearing container can be mapped over the successful branch while preserving the error state.
Functions as a functor: In some languages, the function type (r -> a) is itself a Functor in its codomain, so fmap corresponds to composing functions: fmap f g = f . g. This lets you build pipelines of functions that transform the final result.
Other data types: IO actions, streams, and various ergonomic wrappers are designed to be Functor instances, allowing a uniform way to lift pure functions into effectful or incremental contexts.
Language ecosystems: In Haskell, fmap is the standard operator provided by the Functor type class and is often defined in terms of type class instances. In other languages, similar capabilities are offered under names like map (for lists), and methods on optional or result-like types, sometimes with slight variances in naming to reflect language syntax.

Relationships to related concepts

fmap vs map: For many languages, particularly those that treat lists as the canonical container, the operation for lists is often named map, and in those contexts fmap and map coincide. The distinction becomes meaningful when generalizing beyond lists to arbitrary Functor-instances.
Applicative functors and beyond: fmap is the core operation for Functor; more expressive abstractions like Applicative functor extend this idea to work with applying wrapped functions to wrapped values, enabling sequencing of effects. In practice, fmap is a member of the broader hierarchy that includes these related concepts.
Lifting and higher-kinded types: Fmap is a simple instance of a more general notion of lifting functions into contexts. This idea underpins many abstractions in typed functional programming and can be extended through higher-kinded types to support a wide range of computational contexts.

Language examples and conventions

In Haskell and related languages, the typical usage is to apply fmap to a function and a functor, producing a new functor with the function applied to each element.
In imperative or multi-paradigm languages, similar effects are achieved with methods that operate on containers or with operators that resemble map, but the conceptual underpinnings are the same: applying a function uniformly to each element inside a structure without altering the structure itself.
Some languages expose fmap as a function in the standard library, while others implement it as a method on the container type or through a syntax that resembles a functor-aware mapping.