Monoids

Functional Programming Ideas and Patterns

This subject is Difficult to approach

• The vocabulary of functional programming can be dense and confusing. (things you don't know are defined in terms of other things you don't know)
• The applicability of these abstract concepts is often unstated.
• Difficult to google things, what does this mean? ⊕

So just academic? Or why do we care?

• There are many foundational patterns that are used throughout functional programming
• Familiarity allows you to identify these patterns in other code and understand it
• You can incorporate these to create clean functional code

Let's look at some Functions

• (+ 1 1) => 2
• (str "Hello" " world") => "Hello world"
• (concat ['a 'b 'c] ['d 'e 'f]) => ['a 'b 'c 'd 'e 'f]

Let's consider the types here:

• (+ int int) => int
• (str string string) => string
• (concat vector vector) => vector

This is the first requirement for monoids

• A monoid takes two items of type x and returns type x
• In math this is called a "closure" which is super confusing because of how that word means something different in CS (closure doesn't need 2)

• (/ 5 2) => 2.5                         (/ int int) => float                                    ~fails~
• (and true false) => false     (and bool bool) => bool                        ~closure~
• (= 2 3) => false                      (= int int) => bool                                   ~fails~
• (count [:a :b]) => 2                 (count vector) => int                              ~fails~
• (concat [:a "fo" :b] [:c 4 2])  (concat vector vector) => vector         ~closure~ 

Why do we care about closures?

You can chain things together easily!

(you've probably been doing this for ages!)

For strings:

        (str host ":" port "/" resource)

For "fluent" apis:

        myService.enableAuth().startService().debug()

For flow control:

        if (x == true and y == true) or .....

More to consider...

  (+ 1 0) => 1

  (concat [1 2] []) => [1 2]

  (str "Hello" "") => "Hello"

Consider in general...

  (+ some-int nothing) => some-int

  (concat some-list empty-list) => some-list

  (str some-string empty-string) => some-string

Second Requirement of Monoids

 We need to have a concept of nothing! 

Or stated more like a math person, 'we need something to give our function, in addition to an "actual" argument, that will always give back the same "actual" argument' (called identity)

• (and x true) => x                                          ~identity~
• (intersection set1 set2) => set3                ~fails~ (universal set doesn't count)
• (* 1 x) => x                                                   ~identity~

Why do we care about Identity?

 It solves a lot of irritating little problems.

Problem: find the max value in a collection.

;; naive imperative approach 
;; (but that we totally have all seen in the wild)

(defn find-max-int [col]
  (loop [max-value (Integer/MIN_VALUE)
         [next-int & remaining] col]
    (if (nil? next-int)
      max-value
      (if (> next-int max-value)
        (recur next-int remaining)
        (recur max-value remaining)))))

;; this works only because clj already
;; understands that addition has an identity of zero
(reduce + [1])

Last thing to consider

  (= (+ 1 2 3)

       (+ 1 (+ 2 3)))  => true

  (= (concat (concat [1 2] [3 4]) [5 6])

      (concat [1 2] (concat [3 4] [5 6])))

  (= (max 1 2 3)

      (max (max 1 2) 3))

Third requirement of Monoids

We can group things however we want (associativity)

( = (* 2 (* 3 4))

     (* 2 3 4))               ~associative~

(not= (/ 2 (/ 3 4))

          (/ 2 3 4))           ~fails~

Why do we care about Associativity?

• Parallelization
• Divide and conquer algorithms
• Incremental algorithms

Consider counting words in a book 

- make it smaller, count one page at a time

- make it parallel, you count page 1, I count page two

- make it incremental, I counted pages 1-5 today, tomorrow I can count page 6 and not recount 1-5

~~ALMOST THERE~~

This is never listed as a formal rule, but it's still a true thing, monoids operate on two arguments, although it's really impossible to satisfy identity without this being true, but it warrants a glance.

(+ int int) ~closed~ ~associative~ ~identity~ ~2 args~

(inc int)  ~closed~ ~not associative~ ~no identity~

Think about Monoids when you're thinking about collections.

Monoids are often a combinatory pattern.

That's what a Monoid is

If we have a function fn that accepts 2 arguments of type x

1) fn in closed over x (fn x x) => x (closure)

2) There is some value x1 that (fn x1 _) => _  (identity)

3) We can group this together as we choose

       (= (fn x1 (fn x2 x3))

            (fn (fn x1 x2) x3)) => true     (associativity)

  ~~~So what! You taught me some math and told me I already know it!

Map-Reduce

Let's start with reduce, what is reduce? (doc reduce)

clojure.core/reduce
([f coll] [f val coll])

f is a "reducing function", it takes 2 arguments and does ~something~ to them. coll is a collection, items are taken one at a time and supplied to f along with the prior evaluation of f (or an initial starting value val).

(reduce + [1 2 3 4])

(+ (+ (+ 1 2) 3) 4) 

(reduce + 0 [1 2 3 4])

(+ (+ (+ (+ 0 1) 2) 3) 4) 

Map-Reduce : 2

At this point our monoid radar is going crazy!

(+ (+ (+ 1 2) 3 ) 4)

We see that these are chaining together safely! (closure)

But maybe reduce actually does this:

(+ (+ 1 2) (+ 3 4))

We don't care (associativity) let the language figure it out.

Map-Reduce : 3

But wait, there's more. What if

(+ (+ 1 2) (+ 3 4))

Blue is an operation handled by node 0

Red is an operation handled by node 1

Then we aggregate on node 0

More parallelism thanks to associativity.

And when we have

(+ 1 2 3 4 5) then what?

(+ (+ 1 2) (+ 3 4) (+ 5 ..))

Identity!

Map-Reduce : 4

This is awesome but I don't live in fantasy land of ints, I live in horror land of java interop.  I have a collection of:

class CompositeProxyFactoryBeanImpl

public int composedProxyFactoryBeans()

Here Map helps us!

(map #(.composedProxyFactoryBeans %) 
  collection-CompositeProxyFactoryBeanImpl)

Map-Reduce : 5

The summary of the pattern:

map the collection to a monoid

reduce the collection

Parting Thought

If we want to combine 2 functions, we can do this:

(comp fn1 fn2)

If we want to comp fn1 to fn2 and always get back fn2

we can use identity

(comp identity fn2) => fn2

Can we use comp/identity as a monoid?

Does it work for any functions or just some?

What does it look like in our code when we do this?  

What patterns do we notice?