It’s commonly used with parser combinators. For example, if space is a parser combinator that matches a single whitespace character, many space would be one that would match consecutive whitespace. I can agree that it’s slightly out of place in Control.Applicative, though.
Another example is a strict left fold. You can write an applicative instance which allows you to compose folds so that the resulting fold can be performed on the data in a single pass and constant space. However, the monad instance needs to re-iterate from the beginning of the data for each bind and keep … Read more
The key to understanding applicative functors is to figure out what structure they preserve. Regular functors preserve the basic categorical structure: they map objects and morphisms between categories, and they preserve the laws of the category (associativity and identity). But a category may have more structure. For instance, it may allow the definition of mappings … Read more
val result: Future[(Class1, Class2, Class3)] = for { _ <- Future.unit val f1 = process1 val f2 = process2 val f3 = process3 v1 <- f1 v2 <- f2 v3 <- f3 } yield (v1, v2, v3)
The “neat alternative presentation” for Applicative is based on the following two equivalencies pure a = fmap (const a) unit unit = pure () ff <*> fa = fmap (\(f,a) -> f a) $ ff ** fa fa ** fb = pure (,) <*> fa <*> fb The trick to get this “neat alternative presentation” … Read more
Every applicative yields an arrow and every arrow yields an applicative, but they are not equivalent. If you have an arrow arr and a morphism arr a b it does not follow that you can generate a morphism arr o (a \to b) that replicates its functionality. Thus if you round trip through applicative you … Read more
I cannot answer it all, but i try on some parts: Is there some reason that the “most asynchronous” behavior—i.e., don’t consume the collection before returning, and don’t wait for each future to complete before moving on to the next—isn’t represented here? If you have dependent calculations and a limited number of threads, you can … Read more
Here’s a couple of functions that use the Monad interface. ifM :: Monad m => m Bool -> m a -> m a -> m a ifM c x y = c >>= \z -> if z then x else y whileM :: Monad m => (a -> m Bool) -> (a -> m a) … Read more
Well, I’m not terribly satisfied with the answers given so far, but I think the comments attached to them are a bit more compelling. So I’ll summarize here: I think there’s only one sensible Functor instance that follows from Applicative: fmap f fa = pure f <*> fa Assuming that’s unique, it makes sense that … Read more
A side effect is an observable interaction with its environment (apart from computing its result value). In Haskell, we try hard to avoid functions with such side effects. This even applies to IO actions: when an IO action is evaluated, no side effects are performed, they are executed only when the actions prescribed in the … Read more