Monads everywhR

A monad is a very useful pattern. If you don’t know what it is, then read my
post from a few years ago, watch
this excellent video, and
you can also read J. Carroll’s insightful
post. Once you think you get
the concept, this blog post will be much more enjoyable. That’s because I’d like
to focus on why monads don’t seem to want to spread in the R language.

After all, R is a functional programming language, and it would be natural for
monads to be part of the basic toolkit, like in Haskell or Rust, yet this isn’t
the case. There have been and are attempts: for example the {chronicler} or
the
{maybe} package, and perhaps more. But I’ve never seen anyone use them in
production, at least not in my field, bioinformatics. In this post, I’d like to
think through why this is the case.

What does a monad need?

• A data type that stores “plain” types (duh…)
• A function that wraps data into the monad (sometimes called return or
  pure)
• A composition operator (bind, >>=) that allows us to chain smaller steps
  into a process even in the monad realm
• Optionally, an unwrapping function that extracts values from the
  container
• It’s also useful to have functions that use the monad data type. 🙂

So there’s the base R realm, where there are plain functions, and we chain
computations (i.e. compose functions) with the pipe operator (|>, %>%), or
with parentheses. And there are the various monad realms: Maybe, List,
Logger/Writer, Either, Promise, where we use the bind operator for the same
purpose. Once we enter such a monad realm, the pipe operator and usual
composition won’t work until we return to the base world. This is because
monadic functions use plain types as input, and produce monad types, so you
can’t simply pipe it into the next function.

In most other programming languages there are built-in, basic data types: Int,
Char, etc., and the various monads are derived from these. R is not a
conventional language in this respect, as it doesn’t have scalar types, only
vectors! The expression a <- 3 actually assigns a vector of length 1 to
variable a, not a double type. This means that in R, the base realm is already
a monad. Here, it’s called a vector, the equivalent of list in other
languages.

Not only that, we’re actually dealing with a monad combination, since every
vector type can have missing values! I think everyone is familiar with
NA_string_ NA_integer_ et al. So “Hello world!” would be a String type in
other languages, but in R it’s basically [ Maybe String ] by default – a
vector of optional strings. For numeric data types, NaN is added to this, which
can be simply interpreted as NA, but differs from it, its type could be
written as [ NaN | NA | Numeric ].

In light of this, maybe there isn’t much point in implementing List and
Maybe monads, since these are present by default, just in a slightly unusual
way not as monads, but in the form of basic data types.

Now that I’m enlightened, I am wondering if one could make use of the fact that
we are already in a monad realm. Maybe we could simplify our code, maybe not.
That should be a topic of another blog post.

Related