Comments on: The basics of applicative functors, put to practical work http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/ Bryan O'Sullivan's blog Wed, 08 Feb 2012 06:41:38 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Gene Arthur http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-251653 Gene Arthur Mon, 14 Dec 2009 15:40:22 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-251653 (* 8) that is supposed to be times 8 -- eight and came out a smiley on my monitor in my comment above.. oh well. (* 8) that is supposed to be times 8 — eight and came out a smiley on my monitor in my comment above.. oh well.

]]> By: Gene Arthur http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-251651 Gene Arthur Mon, 14 Dec 2009 15:37:34 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-251651 Harkening back to the original premise of this entry, I would like to plug the versatility aspect of the applicatives on functors as opposed to using the monadic machinations. The problem with using monads and bind comes in the type situation. The monads have to match if outside of bind for the next level monad down, as in this situation: catMaybes $ [1..12] >>= ((\x -> if x >> return) >>= (liftM (* 8) >>> return) [40,48,56,64,72,80,88,96] Using applicative operators along with arrows you get the above with the catMaybe on the inside of the computational unit which is not possible as far as I can see with a single monad construction, without resorting to using the ($) outside of the application. Here is the same thing using the () from Control.Applicative and a new operator that I built, () that just extends down another functor layer: () :: forall a b (f1 :: * -> *) (f :: * -> *). (Functor f, Functor f1) => (a -> b) -> f1 (f a) -> f1 (f b) *Big3> ((\x -> if x < 5 then Nothing else Just x) ) >>> ((* 8) ) >>> catMaybes $ [1..12] [40,48,56,64,72,80,88,96] I will have to delve into Parsec module someday, but been having WAY to much fun, mucking about with other things. Cheers, gene Harkening back to the original premise of this entry, I would like to plug the versatility aspect of the applicatives on functors as opposed to using the monadic machinations.
The problem with using monads and bind comes in the type situation. The monads have to match if outside of bind for the next level monad down, as in this situation:

catMaybes $ [1..12] >>= ((\x -> if x >> return) >>= (liftM (* 8) >>> return)

[40,48,56,64,72,80,88,96]

Using applicative operators along with arrows you get the above with the catMaybe on the inside of the computational unit which is not possible as far as I can see with a single monad construction, without resorting to using the ($) outside of the application. Here is the same thing using the () from Control.Applicative and a new operator that I built, () that just extends down another functor layer:
()
:: forall a b (f1 :: * -> *) (f :: * -> *).
(Functor f, Functor f1) =>
(a -> b) -> f1 (f a) -> f1 (f b)

*Big3> ((\x -> if x < 5 then Nothing else Just x) ) >>> ((* 8) ) >>> catMaybes $ [1..12]

[40,48,56,64,72,80,88,96]

I will have to delve into Parsec module someday, but been having WAY to much fun, mucking about with other things.

Cheers,
gene

]]> By: Hans van Thiel http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-223956 Hans van Thiel Fri, 17 Apr 2009 12:10:16 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-223956 But to parse the non-context free string of n 'a' followed by n 'b' followed by n 'c' characters you do need the monadic structure. Example taken from: 'Combinator Parsing: A Short Tutorial' by S.Doaitse Swierstra p_abc :: CharParser st String p_abc = do as <- many (char 'a') let n = length as bs <- pnTimes n (char 'b') cs <- pnTimes n (char 'c') return (as ++ bs ++ cs) pnTimes :: Int -> CharParser st a -> CharParser st [a] pnTimes 0 p = return [] pnTimes n p = (:) <$> p <*> pnTimes (n-1) p ApplicativeParsec> parseTest p_abc "aaabbbccc" "aaabbbccc" But to parse the non-context free string of n ‘a’ followed by n ‘b’ followed by n ‘c’ characters you do need the monadic structure. Example taken from:
‘Combinator Parsing: A Short Tutorial’ by S.Doaitse Swierstra

p_abc :: CharParser st String
p_abc = do as <- many (char ‘a’)
let n = length as
bs <- pnTimes n (char ‘b’)
cs <- pnTimes n (char ‘c’)
return (as ++ bs ++ cs)

pnTimes :: Int -> CharParser st a -> CharParser st [a]
pnTimes 0 p = return []
pnTimes n p = (:) <$> p <*> pnTimes (n-1) p

ApplicativeParsec> parseTest p_abc “aaabbbccc”
“aaabbbccc”

]]> By: Hans van Thiel http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-223783 Hans van Thiel Thu, 16 Apr 2009 19:27:35 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-223783 and forgot all about the < and > escape sequences, also as above. Tss,Tss...sorry! and forgot all about the < and > escape sequences, also as above. Tss,Tss…sorry!

]]> By: Hans van Thiel http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-223782 Hans van Thiel Thu, 16 Apr 2009 19:22:59 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-223782 Thanks for this example, which I found through Brent Yorgey's 'The Typeclassopedia' article in 'The Monad Reader', Issue 13. For those not too familiar with Parsec (like myself), here are some examples, using Hugs: ApplicativeParsec> parseTest p_query "name=bryan+o%27sullivan&city=san+francisco" [("name",Just "bryan o'sullivan"),("city",Just "san francisco")] You need the parseTest function to run the example interactively. ApplicativeParsec> parseTest p_headers "Subject: RFC2822 or HTTP (or MIME, or what have you\n\n" [("Subject","RFC2822 or HTTP (or MIME, or what have you")] Note the 2 newlines at the end, which terminate the input in this text format. I replaced the liftA2 in the source code with and , as explained above. Thanks for this example, which I found through Brent Yorgey’s ‘The Typeclassopedia’ article in ‘The Monad Reader’, Issue 13.
For those not too familiar with Parsec (like myself), here are some examples, using Hugs:

ApplicativeParsec> parseTest p_query “name=bryan+o%27sullivan&city=san+francisco”
[("name",Just "bryan o'sullivan"),("city",Just "san francisco")]

You need the parseTest function to run the example interactively.

ApplicativeParsec> parseTest p_headers “Subject: RFC2822 or HTTP (or MIME, or what have you\n\n”
[("Subject","RFC2822 or HTTP (or MIME, or what have you")]

Note the 2 newlines at the end, which terminate the input in this text format.

I replaced the liftA2 in the source code with and , as explained above.

]]> By: augustss http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-122286 augustss Thu, 07 Feb 2008 09:38:58 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-122286 It's interesting how the point free style of parser combinators are coming back into vogue after being displaced by monadic combinators for a while. The point free combinators was how I started (as pioneered(?) by Burge in "Recursive Programming Techniques" in the 70s). It’s interesting how the point free style of parser combinators are coming back into vogue after being displaced by monadic combinators for a while.
The point free combinators was how I started (as pioneered(?) by Burge in “Recursive Programming Techniques” in the 70s).

]]> By: Brent Yorgey http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-122174 Brent Yorgey Thu, 07 Feb 2008 02:00:29 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-122174 Argh! it ate all my angle brackets! ok, take two, fingers crossed... Instead of liftA2, you can also use another nice set of Applicative combinators, <$> and <*>. liftA2 foo x y becomes foo <$> x <*> y One of the nice things about this is that it generalizes easily to liftA3, liftA4, … that is, liftAn foo x1 x2 … xn becomes foo <$> x1 <*> x2 <*> … <*> xn. (For those who might care, note that <$> is just a synonym for fmap! And <*> applies a function “inside” an applicative to a value inside another applicative.) Argh! it ate all my angle brackets! ok, take two, fingers crossed…

Instead of liftA2, you can also use another nice set of Applicative combinators, <$> and <*>.

liftA2 foo x y

becomes

foo <$> x <*> y

One of the nice things about this is that it generalizes easily to liftA3, liftA4, … that is,

liftAn foo x1 x2 … xn

becomes

foo <$> x1 <*> x2 <*> … <*> xn.

(For those who might care, note that <$> is just a synonym for fmap! And <*> applies a function “inside” an applicative to a value inside another applicative.)

]]> By: Brent Yorgey http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/comment-page-1/#comment-122172 Brent Yorgey Thu, 07 Feb 2008 01:58:12 +0000 http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/#comment-122172 Instead of liftA2, you can also use another nice set of Applicative combinators, and . liftA2 foo x y becomes foo x y One of the nice things about this is that it generalizes easily to liftA3, liftA4, ... that is, liftAn foo x1 x2 ... xn becomes foo x1 x2 ... xn. (For those who might care, note that is just a synonym for fmap! And applies a function "inside" an applicative to a value inside another applicative.) Instead of liftA2, you can also use another nice set of Applicative combinators, and .

liftA2 foo x y

becomes

foo x y

One of the nice things about this is that it generalizes easily to liftA3, liftA4, … that is,

liftAn foo x1 x2 … xn

becomes

foo x1 x2 … xn.

(For those who might care, note that is just a synonym for fmap! And applies a function “inside” an applicative to a value inside another applicative.)

]]>