All monads in Haskell are only monads if you exclude the weird seq combinator. This is also true for IO. Since seq is not actually a regular function but involves magic, you have to exclude it from checking the monad laws for the same reason you have to exclude unsafePerformIO. Using seq you can prove … Read more
As Michael said, the issue is buffering. By default, output is buffered until you print a newline (or until the buffer is full if you have really long lines), so you’ll most often see this issue when trying to do same-line prompts using putStr like you’re doing. I suggest defining a small helper function like … Read more
Take the following mini-language: data Action = Get (Char -> Action) | Put Char Action | End Get f means: read a character c, and perform action f c. Put c a means: write character c, and perform action a. Here’s a program that prints “xy”, then asks for two letters and prints them in … Read more
To see why you get the particular answers that arise, the desugaring explanations are very helpful. Let me supplement them with a little general advice about developing perceptions of Haskell code. Haskell’s type system makes no distinction between two separable “moral” purposes: [x] the type of values which are lists with elements drawn from x … Read more
Kleisli aka ReaderT is from practical point of view #2 (and as I show later #3) – dependency injection of one the same component into several functions. If I have: val makeDB: Config => IO[Database] val makeHttp: Config => IO[HttpClient] val makeCache: Config => IO[RedisClient] then I could combine things as a monad this way: … Read more
mplus is exactly what you’re looking for, part of the MonadPlus typeclass. Here’s its definition: instance MonadPlus Maybe where mzero = Nothing Nothing `mplus` ys = ys xs `mplus` _ys = xs To use it in your case: combined x = (f x) `mplus` (g x) `mplus` (h x)
There is no specific implementation for IO; it’s an abstract type, with the exact implementation left undefined by the Haskell Report. Indeed, there’s nothing stopping an implementation implementing IO and its Monad instance as compiler primitives, with no Haskell implementation at all. Basically, Monad is used as an interface to IO, which cannot itself be … Read more
For a given type r, the function of type r -> a can be thought of as a computation delivering an a using an environment typed r. Given two functions r -> a and a -> (r -> b), it’s easy to imagine that one can compose these when given an environment (again, of type … Read more
You are not making a mistake. The key idea to understand here is currying – that a Haskell function of two arguments can be seen in two ways. The first is as simply a function of two arguments. If you have, for example, (+), this is usually seen as taking two arguments and adding them. … Read more
The precise technical definition: A monad, in Ruby, would be any class with bind and self.unit methods defined such that for all instances m: m.class.unit[a].bind[f] == f[a] m.bind[m.class.unit] == m m.bind[f].bind[g] == m.bind[lambda {|x| f[x].bind[g]}] Some practical examples A very simple example of a monad is the lazy Identity monad, which emulates lazy semantics in … Read more