How do you implement square (or double) using Monads?

Quite simple: Use the monad instance of a function and then join on a function that returns a function.

How on earth does that work?

You know the signature of Monad join.

join :: Monad f => f (f a) -> f a
join ffa = ffa >>= id

Consider data Optional a = Full a | Empty has a monad instance. This implies:

>> join (Full (Full 1))
 Full 1

In this case, f is Optional, and ffa is Full (Full 1)

When you replace Optional to be a function f: t -> a, then ffa is f: t -> ( t -> a ).

As an example:

>> ffa = \x -> (\y -> x * y)
>> ffa 2 3
 6

ffa = \x -> (\y -> x * y)) is same as ffa = (*)

Thinking along the same lines, calling join on ffa to return fa means converting t-> (t -> a) to t -> a

Let’s do that:

>> :type (join (*))
 (join ffa) :: Num a => a -> a

join (*) returns a function Int -> Int effectively.

>> join (*) 10
 100

This implies:

>> square = join (*)
>> double = join (+)

Yea, that was more of a fun. But you can sort of guess that monad instance of a function (->) t involves passing the same argument twice to a binary function. I will explain this blog with some Scala later, although I found it a little less intuitive considering I cannot write join(*) or (*).join after the required imports from cats/scalaz. But it will still be a good exercise.