Jamesward.com Website Review

There comes a point in every Functional Programmer’s life where they feel the curse of the Monad has lifted and they must now explain Monads to their friends who just don’t get it. What follows is probably wrong and confusing, cause there is no escaping the curse. Suppose you have a system property that contains the name of another system property, like: So there is a chain of operations. We need to first lookup the KEYNAME value and then use that to lookup another value. String prop = null; String keyname = system.getProperty(KEYNAME); if (keyname != null) {   prop = system.getProperty(keyname); String prop = null; String keyname = system.getProperty(KEYNAME); if (keyname != null) { prop = system.getProperty(keyname); } In the functional world we can instead use a type that represents the nullable value, usually called an Option, like: Now we can’t use the maybeKeyname to lookup the second value because it might be None and props.get doesn’t take an Option: So we need to chain together two options. We can do this with Monads via a flatMap function: There are many different chainable types. Another is a Try for things that can fail. For example, if we want to ask a user for two numbers and add them together, but handle number parsing failures we can do this:   num1 <- Try(StdIn.readLine(Number 1: ).toInt)   num2 <- Try(StdIn.readLine(Number 2: ).toInt) If you enter two numbers you get a Success but if either number is not an integer then the result will be a Failure. Another Monadic type is Future which may hold a value later (i.e. async). You can chain futures together like Option and Try, for import scala.concurrent.{Promise, Future} import scala.concurrent.ExecutionContext.Implicits.global Monads just help us chain together operations on items in some form of container. In these examples the chains have been short (two operations) but could be much longer – making the value more apparent.