Could std::unique_ptr be considered a monad?

Question

I'm currently trying to wrap my head around monads. Unfortunately, most articles on the topic use Haskell without properly explaining the notation. Yet, as I am mainly programming in C++, I would like understand monads without learning a new programming language...

From what I gathered on the web, a monad M is a type constructor for a type T, which provides at least the following operations:

• an actual way to construct the type T
• a converter for converting an arbitrary type to T (apparently called return in Haskell)
• a combinator for applying the value stored in T to a function f (apparently called bind in Haskell)

Applying these criteria to C++, it seems to me that std::unique_ptr could be considered a monad. Is this true?

---

My reasoning is as follows:

The std::unique_ptr template is used to construct the actual type std::unique_ptr<T>, thus:

• the type constructor is either std::unique_ptr<T>{} or std::make_unique<T>()
• the converter, again, would be the constructor or std::make_unique (with arguments...)
• the combinator would be either std::bind(func, pointer.get()), std::bind(func, *pointer) or an equivalent lambda

Do you agree, or does the call to operator*()/.get() for the combinator disqualify std::unique_ptr from being a monad?

---

I get, that using std::unique_ptr as a monad might not make sense because it carries owner semantic. I would just like to know, if it is one.

Answer 1

Applying these criteria to C++, it seems to me that std::unique_ptr could be considered a monad. Is this true?

Your definition is missing the monad laws, but we can see that there is appropriate formulation by which std::unique_ptr (plus it's bind and return/unit) obeys them.

Given

template <typename T>
std::unique_ptr<T> unit(T t) { return std::make_unique<T>(t); }

template <typename T, typename U, typename F = std::function<std::unique_ptr<U>(T)>>
std::unique_ptr<U> bind(std::unique_ptr<T> ptr, F f) { return ptr ? f(*ptr) : nullptr; }

and a notion of expression equivalence (≡), i.e. "these two expressions result in the same value"

We require

• Left identity: bind(unit(a), f) ≡ f(a)
• Right identity: bind(m, unit) ≡ m
• Associativity: bind(bind(m, f), g) ≡ bind(m, [](auto x){ return bind(f(x), g); })

I get, that using std::unique_ptr as a monad might not make sense because it carries owner semantic. I would just like to know, if it is one.

A monad is something that applies a semantic, like unique_ptr's ownership, or vectors multiplicity, or future's asynchronicity. There are lots of things in C++ that are monads, but (as @NicolBolas notes) there isn't much that operates on the monadic structure.

Answer 2

I don't think the std::bind is the same thing as a monadic bind, despite having the same name.

Your reasoning is on the right path though. return is trivial for most types. bind is a little trickier. Say you have a function f that that takes an A and returns a std::unique_ptr<B>. The bind would need to take a pointer to f and a std::unique_ptr<A> as arguments, and return a std::unique_ptr<B>. This function may not be already in the standard library, but it wouldn't be too difficult to write. It basically "unwraps" the std:unique_ptr<A> into an A, then calls f on it.

People get hung up on wanting one abstract bind that will work for any monad, like in Haskell's typeclass. That undoubtedly makes it easier to use monads, but it isn't a requirement to identify one conceptually.

I personally think the array monad is the easiest to grasp, because people are so familiar with it they may not even realize it's a monad. Say you have a function f that takes a string and returns an array of the characters in the string. Calling bind(f, ["two", "strings"]) would return ['t', 'w', 'o', 's', 't', 'r', 'i', 'n', 'g', 's']. If you have a g that takes an integer n and returns an array from 1 to n, then you can use the exact same bind function to do bind(g, [2, 0, 3]) with a result of [1, 2, 1, 2, 3].