Well, there’s lazy, and then there’s lazy. mapM is indeed lazy in that it doesn’t do more work than it has to. However, look at the type signature: mapM :: (Monad m) => (a -> m b) -> [a] -> m [b] Think about what this means: You give it a function a -> m … Read more
The first issue can easily be bypassed by always providing a function with the right type a -> Promise a. Or by not using then as the bind operation of the monad, but some type-correct ones. Creed is a functionally minded promise library that provides map and chain methods which implements the Fantasy-land spec for … Read more
The collections library does backflips to accommodate subtyping: when you use map on a specific collection type (list, map, etc.), you’ll (usually) get the same type back. It manages this through the use of an extremely complex inheritance hierarchy together with type classes like CanBuildFrom. It gets the job done (at least arguably), but the … Read more
You can’t have an unsequence :: (Monad m) => m [a] -> [m a]. The problem lies with lists: you can’t be sure how may elements you are going to get with a list, and that complicates any reasonable definition of unsequence. Interestingly, if you were absolutely, 100% sure that the list inside the monad … Read more
One way to think of this is that a value of type IO a is a “recipe”, containing a list of instructions that if performed would have side effects. Constructing that “recipe” though, does not have any side effects. So a haskell program (whose type is IO ()) is basically a computation that constructs such … Read more
As discussed in the Scalaz group, the problem seems to be that ap would accumulate errors whereas (pseudo-)monadic composition would only operate on the value part of Validation. Therefore, one cannot be expressed in terms of the other and thus no monad instance exists for Validation.
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 s keeps objects inside the ST monad from leaking to the outside of the ST monad. — This is an error… but let’s pretend for a moment… let a = runST $ newSTRef (15 :: Int) b = runST $ writeSTRef a 20 c = runST $ readSTRef a in b `seq` c Okay, … Read more
It’s a frequently asked question: How do I extract ‘the’ value from my monad, not only in Haskell, but in other languages as well. I have a theory about why this question keeps popping up, so I’ll try to answer according to that; I hope it helps. Containers of single values You can think of … Read more
I want to show you that your idea is an instance of a more general concept – zipping. Here’s a version of your program that employs a simpler and more functional style. Applicative Functors Here’s the definition of Applicative: class Functor f => Applicative f where pure :: a -> f a (<*>) :: f … Read more