| Here, try this... A monoid is made up of: - Some arbitrary type of thing. (Lists, sets, strings, numbers, whatever.) Let's call it 'A'. - A value of type A. Let's call it the 'empty' value. - A function that takes two A values as arguments, and returns a single one. Let's call it 'combine' function. Here are some examples of monoids: - String concatenation: 'combine' is string concatenation, and 'empty' is the empty string. - Integer plus: 'combine' is the usual + operation, and 'empty' is the value 0. - Set union: 'combine' is the union of two sets, and 'empty' is the empty set. You can come up with monoids for all sorts of things: maps, lists, functions, bloom filters, futures / promises, ... There are, however, a couple rules: - It doesn't matter which order you combine things in: `("hello" + "world") + "!"` has the same result as `"hello " + ("world" + "!")`; and `1 + (2 + 3)` has the same result as `(1 + 2) + 3`. - You can add the 'empty' value to either end without changing anything. `"" + "hello"` is the same as `"hello" + ""` and plain old `"hello"`. Likewise, `3 + 0 == 0 + 3 == 3`. That's it! To get an intuition, you might want to pick a couple more types from the list above and pick a good 'empty' / 'combine' function that satisfies the rules. Of course, why you'd want to do this is another question. (And one I'd be happy to answer, if you're curious.) |