Functional patterns on OOFP 2025-26

Pipeline

Mon, 01 Jan 0001 00:00:00 +0000

Pipeline #

We will see in this section how functional languages provide a convenient syntax to compose functions that modify lists.

This lets us apply a sequence of operations (filter, transform, aggregate, etc.) to a stream of incoming data, analogously to Unix-like pipes. This style of programming also pairs well with functors and monads, which we will see in later sections.

Thanks to lazy evaluation, each operation in the pipeline can start feeding partial results to the next one, even if it has not finished processing its input list.

Functor

Mon, 01 Jan 0001 00:00:00 +0000

Functor #

The notion of functor comes from a branch of mathematics called category theory.

For programmers, a functor can be viewed as a generic type that implements a certain function (called fmap in Haskell), while respecting certain constraints.

In Haskell #

Definition. Functor in Haskell is a type class.

A type t that belongs to this class must:

be a generic type (with a single type variable), and

implement the function
fmap :: (Functor t) => (a -> b) -> t a -> t b

Terminology. The function fmap lifts a function

Monad

Mon, 01 Jan 0001 00:00:00 +0000

Monad #

Like functors, monads come from category theory.

For programmers, a monad can be viewed as a functor that implements additional functions, while respecting certain constraints.

Monads serve a variety of purposes in functional programs. This includes (among other) writing to a log, or reading data.

In this section, we will only focus on two of the simplest monads, namely the type of lists and the option type (as we did for functors).