Comments by "LoneTech" (@0LoneTech) on "What is a Monad? - Computerphile" video.

You're simply stating that you're stuck in a rut. Take a moment to consider what Null in SQL is. You're almost certainly using the pattern of monads already (LINQ is another example), but understanding the abstraction can help. Also, a few companies that don't exist as we know them in the "real world" you describe would be AT&T, Facebook, Google, Intel, Microsoft, NVIDIA and Qualcomm. Just because you've gone years without using a tool doesn't mean the tool isn't of use. Why use a screw when two nails would do?
13
Yes, they use just about every tool. When a tool sticks, like Haxl, you can be pretty sure it was effective.
7
The summary in the first sentence is a bit off target; the first part describes a type class (which Monad is; another example is Num for numeric, which contains arithmetic operations), and the second part is already enabled by sum types holding fields (which Maybe is; so is Either, and both have instances of Monad). But neither describes the concept of a monad. The prelude describes it thusly: "it is best to think of a monad as an abstract datatype of actions". A monad in Haskell provides a way to sequence processing steps; they could pass information from one to the next, return information, be skipped, repeated, or even reordered. For instance, the STM monad (which allows shared mutable state in multithreaded programs without locking) can repeat actions which it determines need to be retried, and the Maybe monad can skip actions it determines receive no input. The IO monad is the most flexible, as it can perform anything at all, including non-deterministic behaviour; it is also isolated, in that the only thing that performs IO actions is the main function. In effect, the main function's job is to produce the sequence of actions that shall be performed. The Either monad can be easily applied as exceptions are, in that it carries information down the fast Left path as well as the thorough Right path, and the Control.Exception module contains support for translating between this form and IO monad exceptions. Many monads do much simpler work; for instance Identity, First, Last, Max, Min, List (called simply [] in the library), Product and Sum. These are used to take the same internal steps and produce different results from them. State provides a way to carry data past steps, so the steps themselves don't need to forward all state. All of these are deterministic and polymorphic.
7
The IO monad is, in Haskell. As it turns out, the concept is useful for more things so there are plenty of other monads.
6
Monads literally are the mechanism to build try..catch! Haskell has throw, try and catch in Control.Exception, and they essentially take impure exceptions from the IO monad (otherwise known as the surrounding world, a rather impure and uncontrollable thing) and transform them into pure types like Either. Pure Haskell code would just produce the Either directly, so it shows in the type of the function, and since that's a monad we don't need to complicate the code much for handling.
6
The main implementation GHC is a compiler (though it has been extended to include a compiling interpreter GHCi). A quick look at the Implementations page of the Haskell Wiki lists at least 9 compilers and 4 interpreters. And even when interpreted, that doesn't make it a scripting language.
3
The first eval function is missing the Val constructor in its argument pattern (included in your later example). The other problem is that GHCi replaced the function rather than adding a pattern when you defined eval (Div x y), thus creating the non-exhaustive pattern. You can define a multiline function like this by wrapping it in :{ and :} in GHCi.
3
No, monads don't mean errors get ignored. You're confusing the limited information of Nothing in the Maybe monad with failure (it's more like Null in SQL; it indicates absence of an optional value). A far more likely monad for handling errors is Either, which has Left and Right values, in which Left values essentially fast forward to the end like exceptions and Right values keep processing. The fail function within Haskell's Monad type class also accepts a reason string. The Either monad is similar to Rust's Result type, with Left being Err and Right being Ok. Haskell's library just tends to be more abstract and doesn't imply that the quicker result is a failure; it might, for instance, be a found result in a search.
3
It's not pure functions that create the problem; it's the boundary between pure and stateful (in particular, uncontrollable state like an ever changing world). Haskell was designed to make purity pervasive in the language, and it uses monads to reason about what is not pure and define the boundary. Languages lacking that definition make it harder to isolate effects as a concept. An example of a half-hearted attempt is Java's explicit exception annotation, rather flawed by not covering some predictable and common exceptions like NullPointerException. Monads as abstraction also work for pure concepts, and that's where we find monads State, Maybe, Either among others. State becomes a pure concept when sequenced using the bind operation of the monad.
2
How about because he's already using that in the basic split between eval (Val n) and eval (Div n m)? It felt awkward as heck to me when he used that big hunk of nested case code rather than a where with pattern matching: eval (Div n m) = maybediv (eval n) (eval m) where maybediv Nothing _ = Nothing maybediv _ Nothing = Nothing maybediv _ (Just 0) = Nothing maybediv (Just n) (Just m) = Just (n ÷ m) But I guess this form is another step removed from the application of the Maybe monad to the problem, as it isn't curried. Reapplying it in safediv doesn't have that issue, however.
2
It gets a bit more abstract then. The monad can transport other state along with the data path described along the steps bound in it (e.g. putStr "What's your name?" >>= (\_ -> getLine) >>= \name -> putStrLn ("Hello " ++ name)). The IO monad handles the outside world by imagining its changes to be part of what the IO monad evaluation does at each step. So from the purely functional view, we have a particular state of the world at each point, rather than an unchanging world. Compare this to what happened with Nothing in the Maybe monad. It couldn't be fed into the bound steps, so it remained within the Maybe monad. And since that meant the steps couldn't all be performed, the Nothing was the only thing that could come out of it in the end. For the IO monad, what we end up with is a world in which time (and possibly I/O) have occurred. You can't just create other worlds, so there's only one actual evaluation in the IO monad, the one in which main runs.
2
A distinct issue he didn't cover, just using (÷) for division (which isn't in the standard library). In Haskell, (/) doesn't work for Int but requires a Fractional type, while `div` does truncated division towards negative infinity and `quot` truncates toward zero. They each have corresponding remainder functions: quot/rem and div/mod. The RealFloat type class includes IEEE floats with infinite values, so (/) can in fact accept a zero divisor.
2
That's a bit like demanding someone explain object oriented programming using GW-BASIC, which doesn't even have subroutine naming or structures. Python doesn't have a type declaration standard (MyPy does) and C doesn't have first class functions. Haskell meanwhile allows writing either without much noise and has monads as a named concept.
2
You're stretching "I can't do this" to 5 minutes? C doesn't have the necessary concepts, so you'd either give up or implement another language, neither of which I'd fit under "doing this in C".
1
Rust's Option is Haskell's Maybe (or Option), and Rust's Result is Haskell's Either. Rust's ? syntax is like Haskell's do notation, and both of those generic types have a and_then method that is like (>>=). Each of those is a monad. Haskell has many defined monads since there is the ability to express that they are monads (and therefore things can be polymorphic across monads). For instance, the same data traversal code can produce various results depending on if it's run in the Min, Max, Product, Sum, First or Last monads.
1
You seem to be confusing Nothing :: Maybe Int with 0 :: Int. They are two distinct values (and Just 0 :: Maybe Int is a third), and safediv :: Int -> Int -> Maybe Int only checks its second argument (the divisor) for 0. eval :: Expr -> Maybe Int only checks for Nothing, which can be factored out using the Maybe monad.
1
I think perhaps the clearest practical example to point to is Facebook's Haxl, used to implement their spam filters. It effectively combines and batches data requests without complicating the rules code that needs the data. Another impressive monad is STM (software transactional memory), which allows reliable lock-free multithreaded shared mutable state (the horror!) by joining parts of a program into retryable transactions that can execute speculatively. But the fact that there are many minor monads (such as ListM, Maybe, Either, Min, Max etc) is what proves the value of the monad concept in itself.
1
Then it cannot be evaluated, as the evaluation would turn into an infinite loop. The expression can still exist, though.
1
Just and Nothing are two constructors for Maybe types, so you can consider it the tag of a tagged union if you wish. Unlike a tagged union in C, the association is in the type system for the compiler to understand, so you can't try to read a value out of a Nothing.
1
Yes, the example expression format is in polish notation - without the reversal.
1
m and n are not Maybe Int, they're Int. This is because they were defined by patterns matching Maybe Int values x and y with Just m or Just n; Just being the constructor of a Maybe a (where a is some type, Int in this case). This type of pattern matching is an important part of Haskell which was used from early on in the video (where eval was defined distinctly for Val and Div cases).
1
Given how many people seem to use the addition operator without understanding the concept of a carry digit, I'd say "difficult pure math concepts" aren't needed to use most tools. It's a little concept we call abstraction. For some of us it's easier to conceptualize what they do by understanding how they're built, but it's not necessary to always consider in detail. As for "under the hood", the use is exposed in the type system (you literally cannot access this possibly missing value without reaching into the Maybe), which you're encouraged to include some annotations for that both explain to the reader and restrict the compiler, and therefore will match (unlike comments). The worst we find in Haskell code is unqualified imports from multiple places, when the compiler will still balk at any ambiguity. "do something; if error" belongs firmly in an environment where only one thing is going on that can cause an error, like DOS batch files. C had to work around it long ago by making thread specific errno variables.
1