Monads, baby!
Today we look at certain kinds of computations from a truly functional perspective:

• computations that might or might not have a value
• computations that might fail
• computations that will finish at some point

But we won't get into math and category theory for this.
We'll see what a monad is from a programming perspective, directly in the Scala language.

You can find today's contents here.

Let's implement some of our own monads.

1. Let's write a monad equivalent with Option. Let's call this Maybe, as in Haskell.
   • create a trait Maybe[T] (remember the [T] is equivalent to Java's <T> syntax for generics)
   • add some functional primitives as methods to Maybe:
     • the monad requirements: map, flatMap, filter
     • zipWith, which receives a Maybe[A] and returns a Maybe[(T,A)]
       The signature is just a tiny bit more complex:
       

       def zipWith[A](other: Maybe[A]): Maybe[(T,A)]

     • exists, which receives a predicate (a function of T to Boolean) and returns true if this instance contains an element which satisfies the predicate
   • add some utility methods to the Maybe trait:
     • isEmpty
     • toList
     • size
   • create two case classes: Just[T] and None and implement the methods
     • what is None, actually? a case class? a case object?
     • methods should be quick to write and probably take two lines of code, at most