- Haskell-Cafe - Haskell.org

The Monad.Reader (14) - Call for copy
by Wouter Swierstra 14 Apr '09

14 Apr '09

Call for Copy The Monad.Reader - Issue 14 Please consider writing something for the next issue of The Monad.Reader. The deadline for Issue 14 is: ** May 15, 2009 ** The Monad.Reader is a electronic magazine about all things Haskell. Check out the website and browse the previous editions to learn more: http://www.haskell.org/haskellwiki/The_Monad.Reader * Submission Details * Get in touch if you intend to submit something -- the sooner you let me know what you're up to, the better. Please submit articles for the next issue to me by e-mail (wouter at chalmers.se). Articles should be written according to the guidelines available from: http://www.haskell.org/haskellwiki/The_Monad.Reader Please submit your article in PDF, together with any source files you used. The sources will be released together with the magazine under a BSD license. Looking forward to your submission, Wouter

1 0

Types and hashes of hashes, trouble for a Java-programmer...
by John Smith 14 Apr '09

14 Apr '09

Hi, a java-programmer running into trouble while trying to learn Haskell. I try to make a hash containing hashes but can not getting a value out of the innermost hash - I keep running into type-trouble where IO and Maybe monad is getting mixed? My attempt: removeMaybeHash x = case x of Just ref -> ref Nothing -> HashTable.new (==) (\key -> key) test = do h <- HashTable.new (==) (\key -> key) h1 <- HashTable.new (==) (\key -> key) HashTable.insert h 3 h1 HashTable.insert h1 1 1000 maybeOuterHash <- HashTable.lookup h 3 res <- removeMaybe (removeMaybeHash maybeOuterHash) 1000 return res Any clues? In java this would be as simple as (pseudocode): h.lookup(3).lookup(1000) Cheers, Pedro

8 17

Monads from Functors
by Sebastian Fischer 14 Apr '09

14 Apr '09

> {-# LANGUAGE Rank2Types #-} Dear Haskellers, I just realized that we get instances of `Monad` from pointed functors and instances of `MonadPlus` from alternative functors. Is this folklore? > import Control.Monad > import Control.Applicative In fact, every unary type constructor gives rise to a monad by the continuation monad transformer. > newtype ContT t a = ContT { unContT :: forall r . (a -> t r) -> t r } > > instance Monad (ContT t) > where > return x = ContT ($x) > m >>= f = ContT (\k -> unContT m (\x -> unContT (f x) k)) Both the `mtl` package and the `transformers` package use the same `Monad` instance for their `ContT` type but require `t` to be an instance of `Monad`. Why? [^1] If `f` is an applicative functor (in fact, a pointed functor is enough), then we can translate monadic actions back to the original type. > runContT :: Applicative f => ContT f a -> f a > runContT m = unContT m pure If `f` is an alternative functor, then `ContT f` is a `MonadPlus`. > instance Alternative f => MonadPlus (ContT f) > where > mzero = ContT (const empty) > a `mplus` b = ContT (\k -> unContT a k <|> unContT b k) That is no surprise because `empty` and `<|>` are just renamings for `mzero` and `mplus` (or the other way round). The missing piece was `>>=` which is provided by `ContT` for free. Are these instances defined somewhere? Cheers, Sebastian [^1] I recognized that Janis Voigtlaender defines the type `ContT` under the name `C` in Section 3 of his paper on "Asymptotic Improvement of Computations over Free Monads" (available at http://wwwtcs.inf.tu-dresden.de/~voigt/mpc08.pdf) and gives a monad instance without constraints on the first parameter.

6 10

Language.Haskell.Parser and literate Haskell source
by Vasyl Pasternak 13 Apr '09

13 Apr '09

Hello, Are there ability to parse literate haskell source with Language.Haskell.Parser, or maybe there is some tool, which converts .lhs files to .hs ? Thanks in advance. -- Best regards, Vasyl Pasternak

3 4

implementing multilingual interface with dynamic language switching
by Vasyl Pasternak 13 Apr '09

13 Apr '09

Hello, Recently, I've tried to use hgettext to implement dynamic language switching and support of several languages simultaneously. All my tries I've described in blog article http://progandprog.blogspot.com/2009/04/multilingual-ui-and-dynamic-languag… . Comments and suggestions are welcome :) -- Best regards, Vasyl Pasternak

1 0

Haskell Weekly News: Issue 113 - April 13, 2009
by Brent Yorgey 13 Apr '09

13 Apr '09

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20090413 Issue 113 - April 13, 2009 --------------------------------------------------------------------------- Welcome to issue 113 of HWN, a newsletter covering developments in the [1]Haskell community. Announcements xmobar-0.9.2. Andrea Rossato [2]announced the release of [3]xmobar-0.9.2, which features a fix for a longstanding resource leakage bug, new nested color definitions, and more. CFP Haskell Symposium 2009. Stephanie Weirich [4]reminded everyone that there are only 4 weeks until the submission deadline for the [5]2009 Haskell Symposium! hmatrix-static: statically-sized linear algebra. Reiner Pope [6]announced the release of [7]hmatrix-static, a thin wrapper over Alberto Ruiz's excellent [8]hmatrix library for linear algebra. The main additions of hmatrix-static over hmatrix are that vectors and matrices have their length encoded in their types, and vectors and matrices may be constructed and destructed using view patterns, affording a clean, safe syntax. haskellmode for Vim now at projects.haskell.org. Claus Reinke [9]announced that the Haskell mode plugins for Vim have just completed their move to their [10]new home, and took the opportunity to reiterate what they can do (quite a lot, it seems), and mention that some screencasts are available. MSem replacement for QSem. ChrisK [11]announced [12]MSem, a proposed replacement module for Control.Concurrent.QSem. Hac5 is almost upon us!. Sean Leather [13]reminded everyone that in six days, tens of crazy/obsessed, type-safe, functional programmers will be converging on Utrecht to commence execution of the [14]5th Haskell Hackathon, from April 17-19, 2009 in Utrecht, The Netherlands! The local organizing team welcomes you all and looks forward to all of the new developments that come out of everyone's undying quest to write more and better code. Yogurt-0.4. Martijn van Steenbergen [15]announced version 0.4 of [16]Yogurt, a functional MUD client. Version 0.4 makes Yogurt available as a standalone executable that is able to dynamically load and reload Yogurt scripts. Elerea, another FRP library. Patai Gergely [17]announced the release of [18]Elerea, aka "Eventless reactivity", a minimalistic FRP implementation that comes with a convenient applicative interface, supports recursive definition of signals and signals fed from outside by IO actions, plays nice with resources, and is the result of some furious hacking. There are working examples to show off the current capabilities of the library, found in the separate [19]elerea-examples package. tree-monad 0.2. Sebastian Fischer [20]announced version 0.2 of the [21]tree-monad package, which provides instances of MonadPlus that represent the search space of non- deterministic computations as a tree. Version 0.2 implements an optimized CPS version of the tree. HCard -- A library for implementing card-like structures.. Joe Fredette [22]announced the release of [23]HCard, a library which supports a card-like data structures and uses associated types to provide shuffling, dealing, and other facilities. It's general enough to support many different types of playing cards; it currently comes with the common "French Deck" (4-suit, 13 card deck that is very common in the US) implemented and an example cribbage scoring application. SVGFonts 0.1. Tillmann Vogt [24]announced his first Haskell library, [25]SVGFonts 0.1, which parses the relatively unknown SVG Font format to produce outlines of characters. The big advantage of this format is that it is XML, which means easy parsing and manipulating. network-bytestring 0.1.2. Johan Tibell [26]announced a new release of [27]network-bytestring, a Haskell library for fast socket I/O using ByteStrings. New in this release is support for scatter/gather I/O (also known as vectored I/O). Scatter/gather I/O provides more efficient I/O by using one system call to send several separate pieces of data and by avoiding unnecessary copying. Jobs Lecturer in Computer Science, University of Leicester. Roy L. Crole [28]announced an opening for a lectureship at the University of Leicester. The successful candidate will have a strong or promising research record in computer science, with a background in formal foundations (either algorithms and complexity, or semantics of programming or modelling languages), and will be able to contribute to undergraduate and postgraduate teaching and supervision in software engineering. Blog noise [29]Haskell news from the [30]blogosphere. * Mark Wassell: [31]Edge Detection in Haskell. * Sean Leather: [32]Latest on the incremental fold and attributes. * Sean Leather: [33]Haskell mode for Vim on a Mac. * Sean Leather: [34]Incremental attributes. * >>> Human Constraints: [35]Haskell Type Hackery. * LHC Team: [36]A new beginning.. * London Haskell Users Group: [37]Don Stewart: Engineering Large Projects in Haskell: A Decade of Haskell at Galois. * Ulisses Costa: [38]More Hylomorphisms in Haskell. * Ulisses Costa: [39]Anamorphisms in Haskell. * London Haskell Users Group: [40]Next Meeting: Don Stewart from Galois. * LHC Team: [41]Hello world!. * mightybyte: [42]Adding Authentication to the Blog App. * Leon Smith: [43]Polynomial multiplication. * Joe Fredette: [44]Card games, scorekeeping, and ... Associated Datatypes?. * mightybyte: [45]Basic Happstack Blog App. * mightybyte: [46]A Standalone Auth Framework for Happstack. * Mads Lindstrøm: [47]Introducing WxGeneric. * happstack.com: [48]2 new projects that use Happstack. * >>> Brant Carlson: [49]Lightning Modeling in Haskell. * Leon Smith: [50]Lloyd Allison's Corecursive Queues. About the Haskell Weekly News New editions are posted to [51]the Haskell mailing list as well as to [52]the Haskell Sequence and [53]Planet Haskell. [54]RSS is also available, and headlines appear on [55]haskell.org. To help create new editions of this newsletter, please see the information on [56]how to contribute. Send stories to byorgey at cis dot upenn dot edu. The darcs repository is available at darcs get [57]http://code.haskell.org/~byorgey/code/hwn/ . References 1. http://haskell.org/ 2. http://article.gmane.org/gmane.comp.lang.haskell.general/17080 3. http://code.haskell.org/~arossato/xmobar/ 4. http://article.gmane.org/gmane.comp.lang.haskell.general/17072 5. http://haskell.org/haskell-symposium/2009/ 6. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56772 7. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hmatrix-static 8. http://www.hmatrix.googlepages.com/ 9. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56495 10. http://projects.haskell.org/haskellmode-vim/ 11. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56761 12. http://haskell.org/haskellwiki/SafeConcurrent 13. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56758 14. http://haskell.org/haskellwiki/Hac5 15. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56747 16. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Yogurt 17. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56731 18. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/elerea 19. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/elerea-examples 20. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56639 21. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/tree%2Dmonad 22. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56573 23. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/HCard 24. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56444 25. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/SVGFonts 26. http://article.gmane.org/gmane.comp.lang.haskell.cafe/56374 27. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/network-bytestri… 28. http://article.gmane.org/gmane.comp.lang.haskell.general/17066 29. http://planet.haskell.org/ 30. http://haskell.org/haskellwiki/Blog_articles 31. http://www.poundstone.org/blog/?p=137 32. http://feedproxy.google.com/~r/splonderzoek/~3/KWqNCgsK1ww/latest-on-increm… 33. http://feedproxy.google.com/~r/splonderzoek/~3/0QNaK4byWhg/haskell-mode-for… 34. http://feedproxy.google.com/~r/splonderzoek/~3/4B0bHoeTCeQ/incremental-attr… 35. http://blog.human-constraints.com/?p=49 36. http://lhc-compiler.blogspot.com/2009/04/new-beginning.html 37. http://www.londonhug.net/2009/04/10/don-stewart-engineering-large-projects-… 38. http://ulissesaraujo.wordpress.com/2009/04/09/more-hylomorphisms-in-haskell/ 39. http://ulissesaraujo.wordpress.com/2009/04/08/anamorphisms-in-haskell/ 40. http://www.londonhug.net/2009/04/09/next-meeting-don-stewart-from-galois/ 41. http://lhc-compiler.blogspot.com/2009/04/hello-world.html 42. http://softwaresimply.blogspot.com/2009/04/adding-authentication-to-blog-ap… 43. http://blog.melding-monads.com/2009/04/07/polynomial-multiplication/ 44. http://lowlymath.net/2009/card-games-scorekeeping-and-associated-datatypes/ 45. http://softwaresimply.blogspot.com/2009/04/basic-happstack-blog-app.html 46. http://softwaresimply.blogspot.com/2009/04/standalone-auth-framework-for-ha… 47. http://lindstroem.wordpress.com/2008/05/03/introducing-wxgeneric/ 48. http://blog.happstack.com/2009/04/06/2-new-projects-that-use-happstack/ 49. http://bayern.stanford.edu/~brant/lightning/ 50. http://blog.melding-monads.com/2009/03/09/lloyd-allisons-corecursive-queues/ 51. http://www.haskell.org/mailman/listinfo/haskell 52. http://sequence.complete.org/ 53. http://planet.haskell.org/ 54. http://sequence.complete.org/node/feed 55. http://haskell.org/ 56. http://haskell.org/haskellwiki/HWN 57. http://code.haskell.org/~byorgey/code/hwn/

2 1

Re: [Haskell-beginners] Why does forkIO also create native threads?
by Peter Verswyvelen 13 Apr '09

13 Apr '09

It seems that it's not the forkIO that is creating native threads (using GHC 6.10.1, -O flag) For example, the following code only has 5 threads on my Windows box, while I fork 10 lightweight threads import System.IO import Control.Concurrent import Control.Monad entry :: Char -> IO() entry c = do forever $ putChar c main = do hSetBuffering stdout NoBuffering mapM_ (forkIO . entry) ['0'..'9'] putStrLn "all forked; press ENTER to quit" getLine However, things can get bizarre. When we change the entry function into entry :: Char -> IO() entry c = do putChar c threadDelay maxBound Then on my machine 13 native threads *are* created. This might make sense because its waiting forever, but native threads are also created for the following code: entry :: Char -> IO() entry c = do putChar c forever $ threadDelay 0 This feels like overkill, so it seems threadDelay always forks a new native thread, although this is not documented. We can also get into the dark corners of GHC's lightweight thread scheduling: a thread switch only happens when memory is allocated on the GC head (but this is documented in the API) So the following code will not work, the runtime seems to get stuck in an infinite loop after the first thread is created. entry :: Char -> IO() entry c = do putChar c forever $ return () In artificial cases like this you can use yield entry :: Char -> IO() entry c = do putChar c forever yield On Mon, Apr 13, 2009 at 10:37 AM, Lych <lych77(a)gmail.com> wrote: > I wrote a simple ECHO server like this: > ---------------------------------------------------- > import Network > import System.IO > import Control.Concurrent > > service cs = do > ln <- hGetContents cs > hPutStr cs ln > service cs > > > acceptloop ls = do > (cs, host, port) <- accept ls > hSetBuffering cs LineBuffering > forkIO (service cs) > acceptloop ls > > main = do > ls <- listenOn (PortNumber 10061) > acceptloop ls > ---------------------------------------------------- > > And tested it with a client that initiates as many parallel > connections as possible. The number of connections can just reach to > 1000+ on my machine, but I thought it should be more, since forkIO > generates lightweight threads. I also examined the number of threads > in this process with some tool and it proved there was one native > thread per connection. When I replaced the 'forkIO' in the program > with 'forkOS', I got an exactly similar result. Have I thought > something wrong about forkIO? > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners >

1 0

Re: [Haskell-cafe] Functions that return functions
by michael rice 13 Apr '09

13 Apr '09

All I meant was a small change: > makeVerifier :: (Int -> Int -> Int) -> Int -> (Int -> Bool) > makeVerifier f m = divides m . foldl (+) 0 . zipWith f [1 .. ] . digits which make some things simpler: > let checkIsbn = makeVerifier (*) 11 <== I liked this syntax better too, and it's what I had originally. BTW, here's a sneaky way do define digits: > digits :: Int -> [Int] > digits = map digitToInt . show <== I haven't gotten to "show" yet. When needed? When not? So then you'd have: > makeVerifier :: (Int -> Int -> Int) -> Int -> Int -> Bool > makeVerifier f m = (== 0) . (`mod` m) . sum . zipWith f [1 .. ] . map digitToInt . show Which looks pretty nice, I think. -- Lennart ======== Very good. I've yet to replace the 'foldl' with 'sum', but will. Eliminating the 'divides' function is also a nice touch. With Haskell it seems there's always a way to make one's code ever briefer, and using built-ins is probably much faster than anything I'd cook up, but it takes time to learn these short-cuts. Thanks for your comments. Michael --- On Mon, 4/13/09, Lennart Augustsson <lennart(a)augustsson.net> wrote: From: Lennart Augustsson <lennart(a)augustsson.net> Subject: Re: [Haskell-cafe] Functions that return functions To: "michael rice" <nowgate(a)yahoo.com> Cc: haskell-cafe(a)haskell.org Date: Monday, April 13, 2009, 10:33 AM All I meant was a small change: > makeVerifier :: (Int -> Int -> Int) -> Int -> (Int -> Bool) > makeVerifier f m = divides m . foldl (+) 0 . zipWith f [1 .. ] . digits which make some things simpler: > let checkIsbn = makeVerifier (*) 11 BTW, here's a sneaky way do define digits: > digits :: Int -> [Int] > digits = map digitToInt . show So then you'd have: > makeVerifier :: (Int -> Int -> Int) -> Int -> Int -> Bool > makeVerifier f m = (== 0) . (`mod` m) . sum . zipWith f [1 .. ] . map digitToInt . show Which looks pretty nice, I think. -- Lennart On Mon, Apr 13, 2009 at 1:09 AM, michael rice <nowgate(a)yahoo.com> wrote: > Example please. > > Michael > > --- On Sun, 4/12/09, Lennart Augustsson <lennart(a)augustsson.net> wrote: > > From: Lennart Augustsson <lennart(a)augustsson.net> > Subject: Re: [Haskell-cafe] Functions that return functions > To: "michael rice" <nowgate(a)yahoo.com> > Cc: haskell-cafe(a)haskell.org, "Daniel Fischer" <daniel.is.fischer(a)web.de> > Date: Sunday, April 12, 2009, 6:59 PM > > You should use an curried function as f instead of a uncurried one. > Uncurried functions are rarely used in Haskell. > > -- Lennart > > On Sun, Apr 12, 2009 at 10:09 PM, michael rice <nowgate(a)yahoo.com> wrote: >> Thanks, guys! >> >> Boy, this bunch of complemented partially applied functions gives a whole >> new meaning to the term "thinking ahead." And the whole shebang is waiting >> on that input integer to set everything in motion. Pretty clever. >> >> >> To generalize, I changed the function to: >> >> makeVerifier :: ((Int,Int) -> Int) -> Int -> (Int -> Bool) >> makeVerifier f m = divides m . foldl (+) 0 . map f . zip [1 .. ] . digits >> >> so, in Haskell >> >> let checkIsbn = makeVerifier (\ (i,d) -> i * d) 11 >> >> let checkUpc = makeVerifier (\ (i,d) -> if odd i then d else 3*d) 10 >> >> let checkCc = makeVerifier (\ (i,d) -> if odd i then d else if d < 5 then >> 2*d else 2*d+1) 10 >> >> let checkUsps = makeVerifier (\ (i,d) -> if i == 1 then -d else d) 9 >> >> >> I think I'm catching on. >> >> Michael >> >> >> >> --- On Sun, 4/12/09, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: >> >> From: Daniel Fischer <daniel.is.fischer(a)web.de> >> Subject: Re: [Haskell-cafe] Functions that return functions >> To: haskell-cafe(a)haskell.org >> Cc: "michael rice" <nowgate(a)yahoo.com> >> Date: Sunday, April 12, 2009, 12:15 PM >> >> Am Sonntag 12 April 2009 17:38:53 schrieb michael rice: >>> The following are exercises 5.10, and 5.11 from the Scheme text "Concrete >>> Abstractions" by Max Hailperin, et al. The text at that point is about >>> writing verifiers to check ID numbers such as ISBNs, credit card numbers, >>> UPCs, etc. >>> >>> ====== >>> >>> Exercise 5.10 >>> Write a predicate that takes a number and determines whether the sum of >>> its >>> digits is divisible by 17. >>> >>> Exercise 5.11 >>> Write a procedure make-verifier, which takes f and m as its two arguments >>> and returns a procedure capable of checking a number. The argument f is >>> itself a procedure of course. Here is a particularly simple example of a >>> verifier being made and used. >>> >>> (define check-isbn (make-verifier * 11)) >>> >>> (check-isbn 0262010771) >>> #t >>> >>> The value #t is the "true" value; it indicates that the number is a valid >>> ISBN. >>> >>> As we just saw, for ISBN numbers the divisor is 11 and the function is >>> simply f(i,d(i)) = i * d(i). Other kinds of numbers use slightly more >>> complicated functions, but you will still be able to use make-verifier to >>> make a verifier much more easily than if you had to start from scratch. >>> >>> ======= >>> >>> Here's the Scheme check-verifier function I wrote, followed by my humble >>> attempt at a Haskell function that does the same thing. Below that are >>> some >>> verifier functions created with the Scheme make-verifier. Admittedly, >>> functions that return functions are Lispy, but perhaps there a Haskelly >>> way >>> to accomplish the same thing? >> >> Functions returning functions are quite natural in Haskell. >> Since usually functions are written in curried form, a function returng a >> function >> corresponds to a function of multiple arguments applied to only some of >> them. >> >>> >>> Michael >>> >>> =============== >>> >>> >>> (define (make-verifier f m) ;f is f(i,d) & m is divisor >>> (lambda (n) >>> (let* ((d (digits n)) >>> (i (index (length d)))) ;(index 3) => (1 2 3) >>> (divides? m (reduce + 0 (map f i d)))))) #f >>> >>> makeVerifier :: (Int -> Int -> Int) -> Int -> (Int -> Bool) >>> >>> makeVerifier f m = \n -> let d = digits n >>> >>> i = [1..(length d)] >>> >>> in \n -> divides m (foldl (+) 0 (map2 f i d)) >>> >>> >> >> makeVerifier f m n = divides m . foldl (+) 0 $ zipWith f [1 .. ] (digits >> n) >> >> just call makeVerifier f m to get your verification function :) >> >> If you don't want to name the last argument: >> >> makeVerifier f m = divides m . foldl (+) 0 . zipWith f [1 .. ] . digits >> >> more point-freeing would be obfuscation. >> Instead of foldl (+) 0, you could also just write sum. >> >>> >>> -- Note: Reduce is just foldl f 0 lst, but map2 is >>> map2 :: (Int -> Int -> Int) -> [Int] -> [Int] -> [Int] >>> map2 f m n = [ f i d | (i,d) <- zip m n] >> >> map2 is zipWith, already in the Prelude. >> >>> >>> -- And here's my digits function >>> digits :: Int -> [Int] >>> digits 0 = [] >>> digits n = rem n 10 : digits (quot n 10) >> >> Unless you are desperate for speed and sure you deal only with positive >> numbers (or know >> that you really want quot and rem), better use div and mod. Those give the >> commonly >> expected (unless your expectation has been ruined by the behaviour of % in >> C, Java...) >> results. >> >>> >>> -- And divides function >>> divides :: Int -> Int -> Bool >>> divides divisor n = 0 == rem n divisor >>> >>> ===== >>> >>> (define check-isbn ;book number >>> (make-verifier >>> * >>> 11)) >>> >>> (define check-upc ;universal product code >>> (make-verifier >>> (lambda (i d) (if (odd? i) d (* 3 d))) >>> 10)) >>> >>> (define check-cc ;credit card >>> (make-verifier >>> (lambda (i d) (if (odd? i) d (if (< d 5) (* 2 d) (+ (* 2 d) 1)))) >>> 10)) >>> >>> (define check-usps ;postal money order >>> (make-verifier >>> (lambda (i d) (if (= i 1) (- d) d)) >>> 9)) >> >> >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >> >> > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > >

1 0

Re: [Haskell-cafe] Functions that return functions
by michael rice 13 Apr '09

13 Apr '09

Example please. Michael --- On Sun, 4/12/09, Lennart Augustsson <lennart(a)augustsson.net> wrote: From: Lennart Augustsson <lennart(a)augustsson.net> Subject: Re: [Haskell-cafe] Functions that return functions To: "michael rice" <nowgate(a)yahoo.com> Cc: haskell-cafe(a)haskell.org, "Daniel Fischer" <daniel.is.fischer(a)web.de> Date: Sunday, April 12, 2009, 6:59 PM You should use an curried function as f instead of a uncurried one. Uncurried functions are rarely used in Haskell. -- Lennart On Sun, Apr 12, 2009 at 10:09 PM, michael rice <nowgate(a)yahoo.com> wrote: > Thanks, guys! > > Boy, this bunch of complemented partially applied functions gives a whole > new meaning to the term "thinking ahead." And the whole shebang is waiting > on that input integer to set everything in motion. Pretty clever. > > > To generalize, I changed the function to: > > makeVerifier :: ((Int,Int) -> Int) -> Int -> (Int -> Bool) > makeVerifier f m = divides m . foldl (+) 0 . map f . zip [1 .. ] . digits > > so, in Haskell > > let checkIsbn = makeVerifier (\ (i,d) -> i * d) 11 > > let checkUpc = makeVerifier (\ (i,d) -> if odd i then d else 3*d) 10 > > let checkCc = makeVerifier (\ (i,d) -> if odd i then d else if d < 5 then > 2*d else 2*d+1) 10 > > let checkUsps = makeVerifier (\ (i,d) -> if i == 1 then -d else d) 9 > > > I think I'm catching on. > > Michael > > > > --- On Sun, 4/12/09, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: > > From: Daniel Fischer <daniel.is.fischer(a)web.de> > Subject: Re: [Haskell-cafe] Functions that return functions > To: haskell-cafe(a)haskell.org > Cc: "michael rice" <nowgate(a)yahoo.com> > Date: Sunday, April 12, 2009, 12:15 PM > > Am Sonntag 12 April 2009 17:38:53 schrieb michael rice: >> The following are exercises 5.10, and 5.11 from the Scheme text "Concrete >> Abstractions" by Max Hailperin, et al. The text at that point is about >> writing verifiers to check ID numbers such as ISBNs, credit card numbers, >> UPCs, etc. >> >> ====== >> >> Exercise 5.10 >> Write a predicate that takes a number and determines whether the sum of >> its >> digits is divisible by 17. >> >> Exercise 5.11 >> Write a procedure make-verifier, which takes f and m as its two arguments >> and returns a procedure capable of checking a number. The argument f is >> itself a procedure of course. Here is a particularly simple example of a >> verifier being made and used. >> >> (define check-isbn (make-verifier * 11)) >> >> (check-isbn 0262010771) >> #t >> >> The value #t is the "true" value; it indicates that the number is a valid >> ISBN. >> >> As we just saw, for ISBN numbers the divisor is 11 and the function is >> simply f(i,d(i)) = i * d(i). Other kinds of numbers use slightly more >> complicated functions, but you will still be able to use make-verifier to >> make a verifier much more easily than if you had to start from scratch. >> >> ======= >> >> Here's the Scheme check-verifier function I wrote, followed by my humble >> attempt at a Haskell function that does the same thing. Below that are >> some >> verifier functions created with the Scheme make-verifier. Admittedly, >> functions that return functions are Lispy, but perhaps there a Haskelly >> way >> to accomplish the same thing? > > Functions returning functions are quite natural in Haskell. > Since usually functions are written in curried form, a function returng a > function > corresponds to a function of multiple arguments applied to only some of > them. > >> >> Michael >> >> =============== >> >> >> (define (make-verifier f m) ;f is f(i,d) & m is divisor >> (lambda (n) >> (let* ((d (digits n)) >> (i (index (length d)))) ;(index 3) => (1 2 3) >> (divides? m (reduce + 0 (map f i d)))))) #f >> >> makeVerifier :: (Int -> Int -> Int) -> Int -> (Int -> Bool) >> >> makeVerifier f m = \n -> let d = digits n >> >> i = [1..(length d)] >> >> in \n -> divides m (foldl (+) 0 (map2 f i d)) >> >> > > makeVerifier f m n = divides m . foldl (+) 0 $ zipWith f [1 .. ] (digits n) > > just call makeVerifier f m to get your verification function :) > > If you don't want to name the last argument: > > makeVerifier f m = divides m . foldl (+) 0 . zipWith f [1 .. ] . digits > > more point-freeing would be obfuscation. > Instead of foldl (+) 0, you could also just write sum. > >> >> -- Note: Reduce is just foldl f 0 lst, but map2 is >> map2 :: (Int -> Int -> Int) -> [Int] -> [Int] -> [Int] >> map2 f m n = [ f i d | (i,d) <- zip m n] > > map2 is zipWith, already in the Prelude. > >> >> -- And here's my digits function >> digits :: Int -> [Int] >> digits 0 = [] >> digits n = rem n 10 : digits (quot n 10) > > Unless you are desperate for speed and sure you deal only with positive > numbers (or know > that you really want quot and rem), better use div and mod. Those give the > commonly > expected (unless your expectation has been ruined by the behaviour of % in > C, Java...) > results. > >> >> -- And divides function >> divides :: Int -> Int -> Bool >> divides divisor n = 0 == rem n divisor >> >> ===== >> >> (define check-isbn ;book number >> (make-verifier >> * >> 11)) >> >> (define check-upc ;universal product code >> (make-verifier >> (lambda (i d) (if (odd? i) d (* 3 d))) >> 10)) >> >> (define check-cc ;credit card >> (make-verifier >> (lambda (i d) (if (odd? i) d (if (< d 5) (* 2 d) (+ (* 2 d) 1)))) >> 10)) >> >> (define check-usps ;postal money order >> (make-verifier >> (lambda (i d) (if (= i 1) (- d) d)) >> 9)) > > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > >

3 2

Re: [Haskell-cafe] Functions that return functions
by michael rice 13 Apr '09

13 Apr '09

Thank you. That's just what I needed. And your second version shows that I needn't use an anonymous function (lambda expression) at all, something that got lost in translation from Lisp to Haskell. First, yes, there was a typo. I couldn't find the original message so had to rewrite. Second, the reason I switched to a tuple argument in the first place is that I read somewhere, "Real World Haskell" I think, that Haskell anonymous functions could only have a single parameter (\ n -> ...). Maybe I didn't read far enough or Haskell has since been updated. Then, one poster didn't like the use of a (tuple) argument because it couldn't be partially applied, but the whole point of anonymous functions is for one off stuff, like these verifiers, where one doesn't want to create a named function that's used just once. In any case, the function we pass to makeVerifier, whether anonymous or in the WHERE of your clarified version, is a function that only appears in the definition of a particular verifier, so what difference can it possibly make whether or not it can be partially applied? That's what I can't get my head around. Thanks again. Michael --- On Sun, 4/12/09, Ross Mellgren <rmm-haskell(a)z.odi.ac> wrote: From: Ross Mellgren <rmm-haskell(a)z.odi.ac> Subject: Re: [Haskell-cafe] Functions that return functions To: "michael rice" <nowgate(a)yahoo.com> Cc: "Daniel Fischer" <daniel.is.fischer(a)web.de>, haskell-cafe(a)haskell.org Date: Sunday, April 12, 2009, 11:59 PM On Apr 12, 2009, at 11:50 PM, michael rice wrote: > I'm not sure what you're trying to tell me, so let's try a specific case. > > > Here's the makeVerifier function that expects its function f to have a single arg, a pair (i,d): > > makeVerifier :: ((Int,Int) -> Int) -> Int -> (Int -> Bool) > makeVerifier f m = divides m . foldl (+) 0 . map f . zip [1 .. ] . digits > > And usage: > let checkCc = makeVerifier (\ (i d) -> if odd i then d else if d < 5 then 2*d else 2*d + 1) 10 > This looks like it has a typo -- did you mean \ (i, d) -> rather than \ (i d) -> ? > > > And here's the old makeVerifier function that expects its function f to have two integer arguments, i & d: > > makeVerifier :: (Int -> Int -> Int) -> Int -> (Int -> Bool) > makeVerifier f m = divides m . foldl (+) 0 . zipWith f [1 .. ] . digits > > And usage: > let checkCc = makeVerifier (\ .... <== Complete this ) 10 > let checkCc = makeVerifier (\ i d -> if odd i then d else if d < 5 then 2*d else 2*d + 1) 10 though I find it a bit nicer to expand it a bit for clarity: checkCc :: Int -> Bool checkCc = makeVerifier f 10 where f i d | odd i = d | d < 5 = 2*d | otherwise = 2*d + 1 -Ross > > --- On Sun, 4/12/09, Ross Mellgren <rmm-haskell(a)z.odi.ac> wrote: > > From: Ross Mellgren <rmm-haskell(a)z.odi.ac> > Subject: Re: [Haskell-cafe] Functions that return functions > To: "michael rice" <nowgate(a)yahoo.com> > Cc: "Daniel Fischer" <daniel.is.fischer(a)web.de>, haskell-cafe(a)haskell.org > Date: Sunday, April 12, 2009, 9:23 PM > > Under the covers of syntax they only have one parameter, but you can write curried lambdas or functions easily: > > \ a b -> a + b > > which is equivalent to > > \ a -> \ b -> a + b > > and also equivalent to the "normal" function syntax > > f a b = a + b > > or > > f a = \ b -> a + b > > -Ross > > On Apr 12, 2009, at 9:09 PM, michael rice wrote: > >> My question was meant in the context of the makeVerifier function, which is passed a lambda expression. It's my understanding that Haskell lambda expressions can have only a single parameter, which is why I changed the function parameter to a pair, (i,d). >> >> How would it be done otherwise? >> >> Michael >> >> >> --- On Sun, 4/12/09, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: >> >> From: Daniel Fischer <daniel.is.fischer(a)web.de> >> Subject: Re: [Haskell-cafe] Functions that return functions >> To: "michael rice" <nowgate(a)yahoo.com> >> Cc: haskell-cafe(a)haskell.org >> Date: Sunday, April 12, 2009, 7:20 PM >> >> Am Montag 13 April 2009 01:09:22 schrieb michael rice: >> > Example please. >> > >> > Michael >> > >> >> Curried: >> >> f :: a -> b -> c >> >> amenable to partial application. >> >> Uncurried: >> >> g :: (a,b) -> c >> >> not easy to apply partially. >> >> The Prelude contains >> >> curry :: ((a,b) -> c) -> (a -> b -> c) >> >> uncurry :: (a -> b -> c) -> ((a,b) -> c) >> >> to convert if needed. >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe > >

2 1