First, a quick disclaimer: “logging” doesn’t usually make sense in general Haskell code, because it assumes some sort of sequential execution that may or may not be meaningful. Make sure you distinguish between logging how the program executes and logging what values are computed. In strict imperative languages these are mostly the same, but in … Read more
I think the best explanation I’ve heard was actually fairly recently on SO. IO Foo is a recipe for creating a Foo. Another common, more literal, way of saying this is that it is a “program that produces a Foo“. It can be executed (many times) to create a Foo or die trying. The execution … Read more
The Haskell community is split on this issue. John Hughes reports that he finds it easier to teach monad transformers than to teach monads, and that his students do better with a “transformers first” approach. The GHC developers generally avoid monad transformers, preferring to roll up their own monads which integrate all the features they … Read more
Before the IO monad was introduced, main was a function of type [Response] -> [Request]. A Request would represent an I/O action like writing to a channel or a file, or reading input, or reading environment variables etc.. A Response would be the result of such an action. For example if you performed a ReadChan … Read more
A summary first Futures can be considered monads if you never construct them with effectful blocks (pure, in-memory computation), or if any effects generated are not considered as part of semantic equivalence (like logging messages). However, this isn’t how most people use them in practice. For most people using effectful Futures (which includes most uses … Read more
This is available here as a .lhs file. The MaybeT transformer will allow us to break out of a monad computation much like throwing an exception. I’ll first quickly go over some preliminaries. Skip down to Adding Maybe powers to IO for a worked example. First some imports: import Control.Monad import Control.Monad.Trans import Control.Monad.Trans.Maybe Rules … Read more
Consider the specific example of IOT Maybe. How would you write a Monad instance for that? You could start with something like this: instance Monad (IOT Maybe) where return x = IOT (Just (return x)) IOT Nothing >>= _ = IOT Nothing IOT (Just m) >>= k = IOT $ error “what now?” where m’ … Read more
The above is all true, but there is one more thing that is handy: flatMap turns a List[Option[A]] into List[A], with any Option that drills down to None, removed. This is a key conceptual breakthrough for getting beyond using null.
This is the Applicative Monad Proposal (AMP). Now whenever you declare something as Monad, you also have to declare it as Applicative (and therefore Functor). Mathematically speaking, every monad is an applicative functor, so this makes sense. You can do the following to remove the error: instance Functor Wrap where fmap f (Wrap x) = … Read more
I’ve written multiple compilers in Haskell, and a state monad is a reasonable solution to many compiler problems. But you want to keep it abstract—don’t make it obvious you’re using a monad. Here’s an example from the Glasgow Haskell Compiler (which I did not write; I just work around a few edges), where we build … Read more