I'd like to share a little Haskell snippet (I wanted to say "idiom" but actually I'm not sure if I've seen it used anywhere else...) that I quite like:

join (,) 9

What does this do? On its own, not much - in fact you just get:

(9,9)

...which you'd have been much better off typing in yourself. Where it can come-in handy though is when writing code in a pointfree style if you have a need to duplicate an anonymous value into both parts of a pair:

functionWhichTakesAPair . join (,) . functionWhichProducesASingleValue

Anyway, how / why does this construct work....?

The

`(,)` is just the standard data constructor for a 2-tuple, a pair. (This constructor has type

`a -> b -> (a,b)` so you can always write

`(,) 9 9` as an alternative notation for

`(9,9)` if you wish).

The

`join` is the standard function

`:: Monad m => m (m a) -> m a` we know from monadic programming (Control.Monad). But this just raises the question of how it can make sense to apply it to

`(,)` which as we've seen is a function of type

`a -> b -> (a,b)`.

The answer is of course that this function may be considered to be of type

`m (m a)`. This is because

`Control.Monad.Instances` declares any partially applied function (eg

`a -> ...`) to be a monad (the type

`a` can be seen as representing an encapsulated environment which is threaded through by the monadic bind). This then means that a function of two arguments (such as

`(,)`) can be seen as having type

`m (m a)` which is just what we need to be able to apply

`join`. The net result is that the single argument of the resulting function (

`join (,)`) is passed in twice as desired.

This of course generalises to functions other than

`(,)` - whenever we use

`join f` where

`f` is a function of two arguments, we end up with a function of one argument which is passed into

`f` twice.