# [Haskell-cafe] Join and it's relation to >>= and return

Rik van Ginneken ginneken at math.kun.nl
Wed Jun 9 12:20:04 EDT 2004

```<snip>

?! I found out what a group is:
?! A group is a monoid each of whose elements is
?! invertible.
?!

OK.

?! Only I still find it weird that join is called a
?! multiplication, because according to the definition of
?! multiplication, there should be an inverse. I think,

No, it ain't.
If you take the natural numbers (0,1,2,3,...),
you have a group structure, with unit being 1 and
with multiplication being multiplication.

If an inverse for 0 would exist, the would be a number x
for which 0*x=x*0=1, which is absurd.

It is more even subtle if one considers the rotation group.
The unit is keeping an object on its place.
The multiplication is doing rotations sequently.
Allright, one has an inverse here, but
the rule (a*b)*c = a*(b*c) doesn't occur; try it with a
banana or an apple!

?! thus that multiplication is only defined on a group.
?! And now still remains: why do they call it a
?! multiplication, while by definition it's not. Or

In mathematics man call things first and then deduces the
rules because of mathematicians hate making explicit coercions
(or type dependencies) all the time!

The most simple structure for which the word "multiplication"
is used, as far as I know is a semigroup (a monoid without a
unit).

?! should I understand it as: there's a concept called
?! multiplication and for different structures there's a
?! definition? I think, now I think over it, that it
?! would seem logical.
?!
?! It could be possible that the definition is incorrect,
?! though. Does anyone knows of a definition that is more
?! general (and not absolute nonsens ;))?
?!

Well, the most general definitions are called "abstract nonsense".

?! The information you give me is *very* usefull, because
?! I don't just want to work with monads, I truly want to
?! understand them.
?!

The first is a group without an invertion.
The latter is a construction in category theory (=abstract nonsense),
for which the word has its origin on monoids, but in
(functional) programming one usually means a specific
construction (OK, based on monads) doing things which are
much harder doing directly.