Output The applicative equivalent for >> is *>, so you can do ghci> :m Control.Applicative ghci> print 5 *> print 7 5 7 Input – a better case for Applicative import Control.Applicative data Company = Company {name :: String, size :: Int} deriving Show getCompany :: IO Company getCompany = Company <$> getLine <*> readLn … Read more
My first ugly approach was: allTerms :: Omega T allTerms = do which <- each [ 1,2,3 ] if which == 1 then return A else if which == 2 then do x <- allTerms return $ B x else do x <- allTerms y <- allTerms return $ C x y But then, after … Read more
In Practice No, it can not be done, at least not in a meaningful way. Consider this Haskell code action :: Int -> IO String action n = print n >> getLine This takes n first, prints it (IO performed here), then reads a line from the user. Assume we had an hypothetical transform :: … 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
I’m with @Rhymoid on this one, I believe all Monads have two (!!) transformers. My construction is a bit different, and far less complete. I’d like to be able to take this sketch into a proof, but I think I’m either missing the skills/intuition and/or it may be quite involved. Due to Kleisli, every monad … Read more
Wadler, School of Haskell, LYAH, HaskellWiki, Quora and many more describe the list monad. Compare: (=<<) :: Monad m => (a -> m b) -> m a -> m b for lists with concatMap :: (a -> [b]) -> [a] -> [b] for m = []. The regular (>>=) bind operator has the arguments flipped, … Read more
A few footnotes to Lee’s answer: However, the bind function looks pretty weird. Why are f and g nested the other way around? Because bind is backwards. Compare (>>=) and its flipped version (=<<): (>>=) :: Monad m => m a -> (a -> m b) -> m b (=<<) :: Monad m => (a … Read more
As a general rule you write something like this: do x <- somethingThatReturnsIO somethingElseThatReturnsIO $ pureFunction x There is no way to get the “Int” out of an “IO Int”, except to do something else in the IO Monad. In monad terms, the above code desugars into somethingThatReturnsIO >>= (\x -> somethingElseThatReturnsIO $ pureFunction x) … Read more
Suppose a function has side effects. If we take all the effects it produces as the input and output parameters, then the function is pure to the outside world. So, for an impure function f’ :: Int -> Int we add the RealWorld to the consideration f :: Int -> RealWorld -> (Int, RealWorld) — … Read more
Here’s an even simpler answer: A Monad is something that “computes” when monadic context is collapsed by join :: m (m a) -> m a (recalling that >>= can be defined as x >>= y = join (fmap y x)). This is how Monads carry context through a sequential chain of computations: because at each … Read more