## Let's Start With Some Basic Information Theory

Information is data. It is something that a human knows (and/or something a human believes that they know, as plenty of humans hold plenty of incorrect beliefs, as humans are want to do) and which (so, my definition has two parts; one of which being that data) can be communicated to another human being (which is to say, I am excluding that which is ineffable from my discussion). Thus, data includes all human created artefacts, including words, text, music, sound, images, graphs, figures, movies and so on.All such artefacts (and in fact, everything in nature) can be digitized. Everything on The Internet has been digitized. So, that covers almost everything on the list right there. And for the remainder, one can create an arbitrary long string of zeros and ones which encodes the state (velocity, motion, direction, and so on and so forth, et al, including position, charge, and spin, as needed and ad nauseam) of any and all sub-atomic particles which comprise the artefact in question.

Thus to the extent something can be knowable, it can be encoded as zeroes and ones.

Unfortunately, not everything is knowable.

## The Limits of Knowledge

At some point in the slicing and dicing of The Universe, one invariably (yes, invariably) reaches a point where further information is unobtainable.Usually, this point is reached when the limits of measurement and recording are reached. Scales are only so accurate. At some level of enlargement, photos get fuzzy. And sound recordings only have so much fidelity.

At which point, the string of zeroes and ones in the data stream start to include unknowns:

`0100?1??001???...`

The question marks (in the preceding data stream) indicate unknowns. And in the Classical View of Things, every last question mark is the result of human error and limitation. However, in the Quantum Mechanic View of Things, at some point of fidelity (say, when looking at the shower of quarks, which results when a boson particle is hit with a semi-polarized field of modularized gamma-energy... or some such nonsense) the question marks are an inherent part of reality.

Classical Universe: question marks exist because humans are, well, human. The

`?`

is in point of fact either a zero or a one, but which one is not known by the human observer.Quantum Universe: question marks exist because that's the way it is. It's not so much that God doesn't know whether the data point is a zero or a one, as God simply hasn't yet decided which one it is to be: i.e. The Universe is a work in progress.

Or to put it more succinctly, it is convenient to use question marks alongside zeroes and ones when encoding The Universe.

## Monads Are So Simple As To Be Trivial

Much is made of Monads in the world of Functional Programming. Monads have been likened unto burritos... likely, by someone who was hungry and suffering from malnutrition at the time, as Monads are nothing like Burritos.Monads are, in fact, quite simple.

A Monad is a Singleton Set (i.e.

`{*}`

) whose only possible operation is The Identity Function (i.e. `↻`

), which is a fancy-smancy mathematical way of saying 'A Monad is a Monad is a Monad' and/or 'A Monad Maps to itself and nothing else.'If

`x`

is a Monad, then the only mathematical operation available to `x`

is `f(x)`

and `f(x)=x`

.As a sidebar, this is of interest to Programmers, as it allows non-state-changing side-effects like printing to screen.

def print_monad(x): print x return x def display_monad(x): display x return x

Now, the above are not really Monads, as they have side-effects (

`print`

and `display`

, respectively). But as state doesn't change (i.e. the output is the same as the input and no variable has been changed on the sly), nobody really cares. Or to be more accurate, the folks who care about Monads don't so much care about `print`

or `display`

, as they care about the state of `x`

(and all the other variables in the program) remaining unchanged by the operation.## The Maybe Monad: One Monad To Rule Them All

OK. Sure. Monads are simple. They're basically dots (a point of datum) with a single arrow that points back to itself (welcome to the exacting world of Abstract Algebra). But Maybe Monads are a whole different ball of wax. And they, oddly enough, are almost exactly like burritos.Ha-Ha!

Just kidding.

Maybe Monads aren't much more complicated than any other type of Monad.

Stated simply, a Maybe Monad might have a value and it might not (hence, the maybe part). But once a Maybe Monad has a value (if ever it does), that value will never change (like, never-ever-ever).

```
FINAL_GRADE(at_semester_start) = unknown
```

FINAL_GRARD(after_grades_post) = A^{+}

A Binary Maybe Monad returns 0 if 0 returns 1 if 1 returns 0, 1, or ? if ?