- Haskell-Cafe - Haskell.org

error handling (esp. IO/exceptions)
by brian＠lorf.org 15 Apr '09

15 Apr '09

I'm finding it hard to write robust code that isn't really ugly. Suppose I want to write > execute :: FilePath -> [String] -> IO (Either ExecuteError ExitCode) where 'ExecuteError' is a data type representing all the ways 'execute' could fail and that 'execute p args' is supposed to * ensure p exists * get p's permissions * ensure p is readable * ensure p is executable * execute p and return its exit code So 'ExecuteError' would have constructors corresponding to these ways to fail: * could not determine whether p exists * p does not exist * could not get p's permissions * p is not readable * p is not executable * could not execute p for some other reason So if I start to code it, I 'tryJust' 'doesFileExist'. If an exception is thrown, I convert it to Left $AppropriateExecuteError. If not, we know whether p exists. If it doesn't, convert it to Left. Otherwise, 'tryJust' 'getPermissions', etc. It's starting to staircase. I'm needing it to be easier to stop my computation and return specific things when exceptions are thrown or when certain requirements aren't met. Thanks for any help.

5 8

lift in TemplateHaskell?
by Lyle Kopnicky 15 Apr '09

15 Apr '09

Hi folks, I'm having trouble reading the TemplateHaskell docs and trying to do something that seems like it should be simple. In MetaML, there is a 'lift' function which does exactly what I want to do. Here's an example function: let double n = [| 2 * $( litE (integerL n) ) |] This works as intended, but instead of writing "litE (integerL n)" I just want to write "lift n", or something similar. I expect that would involve a type class called something like Liftable that would lift literals using the appropriate functions. Does this exist? Thanks, Lyle

1 1

Re: [Haskell-cafe] Printing list of enum type
by michael rice 15 Apr '09

15 Apr '09

I didn't know that, but there's a lot I don't know about Haskell. It works great. Thanks! Michael --- On Tue, 4/14/09, John Dorsey <haskell(a)colquitt.org> wrote: From: John Dorsey <haskell(a)colquitt.org> Subject: Re: [Haskell-cafe] Printing list of enum type To: "michael rice" <nowgate(a)yahoo.com> Cc: haskell-cafe(a)haskell.org Date: Tuesday, April 14, 2009, 3:33 PM Michael, > What do I need to add to this Color enum type to print a list of them? You can also easily print a list of /all/ of them. Regards, John scratch$ cat color.hs data Color = Red | Blue | Green | Yellow | Orange | Brown | White | Black deriving (Show,Enum,Bounded) scratch$ ghci color.hs *Main> [minBound..maxBound] :: [Color] [Red,Blue,Green,Yellow,Orange,Brown,White,Black]

1 0

GHC needs a 64 bit machine to be fast?
by FFT 15 Apr '09

15 Apr '09

Not that this is a very good benchmark, but I compiled the nearly equivalent C and Haskell (1st, recursive version) programs from this blog post: http://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-h… There, in both versions, 1e9 iterations take 1.8s. However, in my timing on 32-bit Linux machines, the C version is 5-10 times faster. Does the bitness of the OS make a big difference? Here are my timings on a 3.4GHz Pentium D: C : 4.072s (GCC 4.2.4) Haskell : 22.481s (GHC 6.10.2 and 6.8.2 are about the same here) I used the exact same compiler options as in the blog post. I only added import System import Text.Printf to the Haskell program, which seems to be missing. Suspiciously, "ghc -O2 --make" is almost as fast at 24.438s (6.10.2)

6 12

Printing list of enum type
by michael rice 15 Apr '09

15 Apr '09

What do I need to add to this Color enum type to print a list of them? Michael =============== data Color = Red | Blue | Green | Yellow | Orange | Brown | White | Black instance Show Color where show Red = "Red" show Blue = "Blue" show Green = "Green" show Yellow = "Yellow" show Orange = "Orange" show Brown = "Brown" show White = "White" show Black = "Black" ====================== Ok, modules loaded: Main. *Main> Red Red *Main> Black Black *Main> [Red Black White] <interactive>:1:1: Couldn't match expected type `Color -> Color -> t' against inferred type `Color' In the expression: Red Black White In the expression: [Red Black White] In the definition of `it': it = [Red Black White]

4 3

Re: [Haskell-cafe] Printing list of enum type
by michael rice 14 Apr '09

14 Apr '09

Dumb, dumb, dumb, dumb, DUMB!, he Lisped. Thanks. Michael --- On Tue, 4/14/09, Andrew Wagner <wagner.andrew(a)gmail.com> wrote: From: Andrew Wagner <wagner.andrew(a)gmail.com> Subject: Re: [Haskell-cafe] Printing list of enum type To: "michael rice" <nowgate(a)yahoo.com> Cc: haskell-cafe(a)haskell.org Date: Tuesday, April 14, 2009, 9:19 AM You don't need to add anything, you just need to use list notation correctly. Try typing [Red, Black, White] in at the prompt instead. The commas are part of the list syntax. On Tue, Apr 14, 2009 at 9:15 AM, michael rice <nowgate(a)yahoo.com> wrote: What do I need to add to this Color enum type to print a list of them? Michael =============== data Color = Red | Blue | Green | Yellow | Orange | Brown | White | Black instance Show Color where show Red = "Red" show Blue = "Blue" show Green = "Green" show Yellow = "Yellow" show Orange = "Orange" show Brown = "Brown" show White = "White" show Black = "Black" ====================== Ok, modules loaded: Main. *Main> Red Red *Main> Black Black *Main> [Red Black White] <interactive>:1:1: Couldn't match expected type `Color -> Color -> t' against inferred type `Color' In the expression: Red Black White In the expression: [Red Black White] In the definition of `it': it = [Red Black White] _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

ANN: hmatrix-static: statically-sized linear algebra
by Reiner Pope 14 Apr '09

14 Apr '09

Hi everyone, I am pleased to announce hmatrix-static[1], a thin wrapper over Alberto Ruiz's excellent hmatrix library[2] for linear algebra. The main additions of hmatrix-static over hmatrix are: - vectors and matrices have their length encoded in their types - vectors and matrices may be constructed and destructed using view patterns, affording a clean, safe syntax. hmatrix-static includes statically-sized versions of hmatrix's linear algebra routines, including: - simple arithmetic (addition, multiplication, of matrices and vectors) - matrix inversion and least squares solutions - determinants / rank / condition number - computing eigensystems - factorisations: svd, qr, cholesky, hessenberg, schur, lu - exponents and sqrts of matrices - norms See http://code.haskell.org/hmatrix-static/examples/ for example code. Installation and requirements: Because of the use of type families and view patterns, hmatrix-static requires GHC 6.10 to build. The linear algebra routines are ultimately implemented by BLAS, GSL and LAPACK; see the hmatrix manual [3] for instructions on installing these, prior to installing hmatrix. Once this has been done, hmatrix-static can be installed by $ cabal install hmatrix-static I would be very interested in your feedback, so please try it out. Kind regards, Reiner Pope [1] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hmatrix-static [2] http://www.hmatrix.googlepages.com/ [3] http://www.hmatrix.googlepages.com/installation

3 3

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 14 Apr '09

14 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 14 Apr '09

14 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 14 Apr '09

14 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 14 Apr '09

14 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 14 Apr '09

14 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

Sequence differences
by michael rice 13 Apr '09

13 Apr '09

I have a Scheme function that calculates sequence differences, i.e., it returns a sequence that is the difference between the 2nd and the 1st element, the 3rd and the 2nd, the 4th and the 3rd, etc. (define s (lambda (f l) (cond ((null? (cdr l)) '()) (else (cons (f (cadr l) (car l)) (s f (cdr l))))))) where (s - '(0,1,3,6,10,15,21,28)) => (1,2,3,4,5,6,7) I'm thinking the same function in Haskell would be something like s :: s f [] = [] s f [x] = [x] s f l = [ a f b | (a,b) <- zip (init l) (tail l)] but can't figure out what the function typing would be. Michael

5 4

binary package: memory problem decoding an IntMap
by Manlio Perillo 13 Apr '09

13 Apr '09

Hi. I'm having memory problems decoding a big IntMap. The data structure is: IntMap (UArr (Word16 :*: Word8)) There are 480189 keys, and a total of 100480507 elements (Netflix Prize). The size of the encoded (and compressed) data is 184 MB. When I load data from the Netflix Prize data set, total memory usage is 1030 Mb. However when I try to decode the data, memory usage grows too much (even using the -F1.1 option in the RTS). The problem seems to be with `fromAscList` function, defined as: fromList :: [(Key,a)] -> IntMap a fromList xs = foldlStrict ins empty xs where ins t (k,x) = insert k x t (by the way, why IntMap module does not use Data.List.foldl'?). The `ins` function is not strict. This seems an hard problem to solve. First of all, IntMap should provide strict variants of the implemented functions. And the binary package should choose whether use the strict or lazy version. For me, the simplest solution is to serialize the association list obtained from `toAscList` function, instead of directly serialize the IntMap. The question is: can I "reuse" the data already serialized? Is the binary format of `IntMap a` and `[(Int, a)]` compatible? Thanks Manlio Perillo

2 4

Control.Concurrent export/import weirdness
by Jason Dusek 13 Apr '09

13 Apr '09

Why is this function exported then imported? foreign export ccall forkOS_entry :: StablePtr (IO ()) -> IO () foreign import ccall "forkOS_entry" forkOS_entry_reimported :: StablePtr (IO ()) -> IO () forkOS_entry :: StablePtr (IO ()) -> IO () forkOS_entry stableAction = do action <- deRefStablePtr stableAction action -- Jason Dusek

2 1

understanding typeable
by Anatoly Yakovenko 13 Apr '09

13 Apr '09

i am trying to figure out how typeable works, so i have this data type data Foo = FooC Int deriving (Data, Typeable, Show) So how come this works: > funResultTy (typeOf ((+) 1)) (typeOf 1) Just Integer but this doesnt: > funResultTy (typeOf FooC) (typeOf 1) Nothing FooC is of type t -> u and 1 is of type t so the result should be u? I don't think t and u need to be the same since > funResultTy (typeOf (\a -> a:[1])) (typeOf 1) Just [Integer] works fine. So given a constructor, how come i cant seem to construct a type out of it?

2 3

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

13 Apr '09

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 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 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, 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

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

13 Apr '09

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.

2 1

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

13 Apr '09

No sweat. My comment was meant humorously. I just forgot the emoticon. Any way you look at it, Haskell is very impressive, and I've just scratched the surface. Michael --- On Sun, 4/12/09, Jake McArthur <jake.mcarthur(a)gmail.com> wrote: From: Jake McArthur <jake.mcarthur(a)gmail.com> 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:27 PM michael rice wrote: > You're getting ahead of me again. I'm sorry. I didn't expect you to understand the whole thing. Rather, I'm just showing what is possible. Notice that there is no lambda abstraction in the function implementation. The entire thing is constructed with combinators, functions that take other functions as arguments. I was trying to emphasize that it is very Haskelly to accept and return functions as happily as normal values. - Jake

1 0

History data structure suggestion
by Victor Nazarov 13 Apr '09

13 Apr '09

Hello, I have a gtk2hs application. I'd like to implement some kind of browser history for it. It should have Back and Forward buttons and a popup menu with radio items.History is a list of strings. There is a current position in this list, so you can move this position back and forward. Some kind of list zipper must be enough to implement this: data History a = Empty | Hist { histBefore :: [a], histCurrent :: a, histAfter :: [a] } back, forward:: History a -> History a back (Hist (b:bs) c as) = Hist bs b (c:as) forward (Hist bs c (a:as)) = Hist (c:bs) a as add :: a -> History a -> History a add x (Hist bs c _) = Hist (c:bs) x [] --- When you add something, future part of history becomes blank. add x Empty = Hist [] x [] start :: History a -> History a start (Hist bs c as) = Hist [] h (hs ++ [c] ++ as) where (h:hs) = reverse bs But there is another requirement. There must be some "points" in the history to store in popup menu. When you select any point the history sould be rolled to this point. For example. data HistPoint a = HP Int current :: History a -> HistPoint a current (Hist bs _ _) = HP (length bs) goTo :: HistPoint a -> History a -> History a goTo (HP n) = foldr1 (.) (replicate n forward) . start I wonder is there more effective, more easy to implement data structure to represent History and HistPoint -- Victor Nazarov

2 1

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

13 Apr '09

You're getting ahead of me again. Michael --- On Sun, 4/12/09, Jake McArthur <jake.mcarthur(a)gmail.com> wrote: From: Jake McArthur <jake.mcarthur(a)gmail.com> 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, 5:45 PM michael rice wrote: > Admittedly, functions that return functions are Lispy, but perhaps there a Haskelly way to accomplish the same thing? Actually, I think you will come to find that this way of thinking is more Haskelly than it is Lispy! import Control.Applicative ((<$), (<*>)) import Control.Arrow ((&&&)) import Control.Monad (guard) import Data.List (unfoldr) makeVerifier f m = (==0) . (`mod` m) . sum . zipWith f [1..] . unfoldr nextDigit where nextDigit = (<$) . (snd &&& fst) . (`divMod` 10) <*> guard . (/= 0) - Jake

2 1

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

13 Apr '09

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))

2 1

Functions that return functions
by michael rice 13 Apr '09

13 Apr '09

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? 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)) -- 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] -- And here's my digits function digits :: Int -> [Int] digits 0 = [] digits n = rem n 10 : digits (quot n 10) -- 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))

4 3

GHC RTS bug: segmentation fault
by Manlio Perillo 13 Apr '09

13 Apr '09

Hi. In a program I have experienced a segmentation fault; not only that but also: * tpp.c:63: __pthread_tpp_change_priority: Assertion `new_prio == -1 || (new_prio >= __sched_fifo_min_prio && new_prio <= __sched_fifo_max_prio)' failed. * internal error: removeThreadFromQueue: not found (GHC version 6.8.2 for i386_unknown_linux) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug I have managed to write a program that reproduces the problem: http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3714 Compile with: $ghc --make -threaded -O2 main.hs Execute with: $./main +RTS -A128M -s -c -N4 -RTS 5000000 500 This should produce a segmentation fault (or one of the previous errors). I strongly suspect that the cause is an uncaught stack overflow. Executing the code with only 1 threads, there are no more problems. Increasing the thread stack size (-k1M), there are no more problems. If the problem is really an uncaught stack overflow, I'm rather sure that a more simple test can be written, to reproduce the problem. I'm on Linux Debian Etch i386; GHC 6.8.2. Some notes about the program: - when no segmentation fault occurs, the program requires about 1 GB of memory - there is no real parallelization, only 1 CPU is used - the mapReduce implementation is taken from Real World Haskell - the code is adapted from the code I'm using in a project Thanks Manlio Perillo

2 1

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

13 Apr '09

Cool. I expected as much. My ISP seems to be swamped (Easter?) so maybe more later after I look at your remarks. Thanks. 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))

1 0

Broken beyond repair: Control.Concurrent.SampleVar
by ChrisK 12 Apr '09

12 Apr '09

Hello all, The SampleVar module in base is not exception safe. I believe that there is no way to fix this module to be exception safe while retaining the current behavior. The problem with the current behavior is that the writeSampleVar pretends to know how many blocked reader threads are waiting on a value. In reality these blocked threads may have been killed. When writeSampleVar sees blocked threads it does a blocking putMVar and then decrements the blocked reader thread count. If any two of the blocked reader threads ever die then eventually you get a blocked writer. I can find no efficient way to retain the current behavior in the presence of exceptions. The logic of the current behavior is that the blocked readers mean that the previously written value should not be discarded, the previous value belongs to the next blocked reader. I propose that SampleVar be either removed, or replaced with a slightly different exception safe version. I propose not considering the previously written value to belong to a blocked reader, and to replace it with the new value. I will open a ticket about this when I get more time. -- Chris

1 0

Bug in Data.Stream?
by Peter Verswyvelen 12 Apr '09

12 Apr '09

Since I realized my code was always using infinite lists, I replaced it by Data.Stream. However, my code stopped working. The problem is with these functions: scan :: (a -> b -> a) -> a -> Stream b -> Stream ascan f z (Cons x xs) = z <:> scan f (f z x) xs-- | @scan'@ is a strict scan.scan' :: (a -> b -> a) -> a -> Stream b -> Stream ascan' f z (Cons x xs) = z <:> (scan' f $! (f z x)) xs They are too strict I think. My code works again when I add a lazy pattern match: scan f z ~(Cons x xs) = z <:> scan f (f z x) xs scan' f z ~(Cons x xs) = z <:> (scan' f $! (f z x)) xs This is justified since they then behave like scanl on lists. However it seems this package is used a lot, so maybe some code depends on this strictness. What to do? PS: Why does scanl' not exist in Data.List?

2 2

How to get glyph outline from ttf font.
by Dmitry V'yal 12 Apr '09

12 Apr '09

Greetings. I'm trying to render some glyphs from ttf font to svg image using gtk2hs cairo binding. Since I can find nothing appropriate in gtk2hs API, I decided to draw outlines with bezier curves myself. But how to get them out of font? As far as I know, freetype library is capable of extracting outlines, but is there any haskell binding for it which supports this functionality? Here [1] one such lib was mentioned, but it wasn't availible online that time. Have situation changed today? Thanks in advance [1] http://www.nabble.com/Re%3A-Rendering-TTF-fonts-in-Haskell-and-OpenGL-p1563…

4 3

what does the hidden package error mean?
by Anatoly Yakovenko 12 Apr '09

12 Apr '09

I am trying to build ParseP on the latest ghc, and i am getting this error: Text/ParserCombinators/ParseP/Interface.hs:26:17: Could not find module `Data.ByteString.Char8': it is a member of package bytestring-0.9.1.4, which is hidden what does "hidden" mean? why does this work in ghci > import Data.ByteString > import Data.ByteString.Char8 > without any problems

5 5

How to define a common return and bind?
by Bas van Dijk 11 Apr '09

11 Apr '09

Hello, Suppose you have defined a monad transformer such as: > newtype T1 m a = T1 { unT1 :: A1 m a } Where 'A1 m' is an arbitrary monad of your choosing. For this discussion we just take the identity: > type A1 m a = m a -- (can be any monad) If you want to define a Monad instance for 'T1 m' you generally do this: instance Monad m => Monad (T1 m) where return = T1 . return m >>= f = T1 $ unT1 m >>= unT1 . f (I know I can use the 'GeneralizedNewtypeDeriving' language extension to automatically derive a Monad but suppose that isn't available) Now when I define a new monad transformer: > newtype T2 m a = T2 { unT2 :: A2 m a } Where 'A2 m' is again an arbitrary monad of your choosing but for now just the identity: > type A2 m a = m a -- (can be any monad) The Monad instance for it is almost completely identical to the former: instance Monad m => Monad (T2 m) where return = T2 . return m >>= f = T2 $ unT2 m >>= unT2 . f Note that the only differences are: * a function to convert from the outer monad _to_ the inner monad: 'unT1' and 'unT2' * a function to convert _from_ the inner monad to the outer monad: 'T1' and 'T2' The common parts seem to be: liftReturn from = from . return liftBind from to m f = from $ to m >>= to . f My question is: can these be given suitable and general enough types so that they can be used to define Monad instances for monad transformers? In other words can I use them to write: instance Monad m => Monad (T1 m) where return = liftReturn T1 (>>=) = liftBind T1 unT1 and: instance Monad m => Monad (T2 m) where return = liftReturn T2 (>>=) = liftBind T2 unT2 Thanks, Bas

3 6

cabal haddock and Paths_Xxx
by Martijn van Steenbergen 11 Apr '09

11 Apr '09

Hello, cabal generates a Paths_Xxx file for me which I import and use, but cabal haddock doesn't seem to like it much. If I don't specify the generated module at all in my cabal file, cabal haddock generates visible documentation for the module, which is not what I want: the module should stay internal. If I specify it in either Exposed-Modules or Other-Modules, 'cabal configure; cabal haddock' fails with: > cabal: can't find source for Paths_Xxx in ., dist/build/autogen While 'cabal configure; cabal build; cabal haddock' fails with: > cabal: can't find source for module Paths_Xxx Can I have the best of both, i.e. generate docs without problems and use the generated module? Thanks, Martijn.

2 2

ANN: MSem replacement for QSem
by ChrisK 11 Apr '09

11 Apr '09

"Grasshopper, try to take the stone from my hand" Hello all, After looking at the code for QSem [1], I realize it is not exception safe. And it does more work than needed. I have a proposed replacement module MSem at http://haskell.org/haskellwiki/SafeConcurrent on the wiki. I claim this is a safer, more correct, and more efficient replacement for QSem. But I may be tragically wrong which is where you come in. Please try and find some strange concurrency bug that I have missed. Once there is reviewed replacement code I will propose changing the base package. Exception safe replacements for QSemN and SampleVar are also needed. The MSem code I have can be generalized into an "MSemN", but the semantics are be different from "QSemN". This MSemN only considers the needs of the first blocked waiter instead of all of them. The code MSemN is on the same wiki page, perhaps someone will find this variant useful. Cheers, Chris [1] http://www.haskell.org/ghc/docs/latest/html/libraries/base/src/Control-Conc…

1 0

ANN xmobar-0.9.2
by Andrea Rossato 11 Apr '09

11 Apr '09

Hi, I'm glad to announce xmobar-0.9.2. What's new: - Norbert Zeh tracked and fixed a longstanding bug that made xmobar leak X resources. This alone makes it worth this release and its public announcement, with the advice to users to upgrade.[*] - Norbert also overhauled the template parser to allow nested color definitions; - Norbert, once again, added the possibility to add color definitions in the monitors' templates. Many thanks to Norbert!! I've read that xmobar lists in the top 25 most downloaded Hackage packages. This is very cool: thanks to all the xmobar users. Hope you'll enjoy. Andrea [*] I tend to believe the same issue affects xmonad, even though it should be visible only after a huge number of restarts. Things get far worse when it comes to the xmonad-contrib library, especially if you use fancy decorations in your layouts: if you see colors you are probably leaking them.

1 0

Hac5 is almost upon us!
by Sean Leather 11 Apr '09

11 Apr '09

In six days, tens of crazy/obsessed, type-safe, functional programmers will be converging on Utrecht to commence execution of... ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The 5th Haskell Hackathon April 17 - 19, 2009 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. As always, you can find lots of useful information on the wiki: http://haskell.org/haskellwiki/Hac5 == Sponsors == We have sponsors! The following companies were very gracious to provide us with support during these tough economic times. * Galois - http://galois.com/ * Microsoft Research - http://research.microsoft.com/ * Tupil - http://tupil.com/ The organizers are incredibly grateful to Galois, MSR, and Tupil for helping to encourage and promote more Haskell hacking. == More To Come == Hopefully, you have already registered, booked your room, and bought your ticket. If not, don't forget that you can keep in touch with the attendees via IRC on Freenode: #haskell-hac5 All registered attendees will soon be receiving an email with more details. Let us know if you have any questions. Happy Hacking! == Organizers == Andres Löh, Utrecht University (UU) José Pedro Magalhães, UU Sean Leather, UU Eelco Lempsink, UU + Tupil Chris Eidhof, UU + Tupil ... and more ...

1 0

Re: [Haskell-cafe] Referential Transparency and Monads
by Brandon S. Allbery KF8NH 11 Apr '09

11 Apr '09

On 2009 Apr 9, at 11:47, Mark Spezzano wrote: > How exactly do monads “solve” the problem of referential > transparency? I understand RT to be such that a function can be > replaced with a actual value. > > Since a monad could potentially encapsulate any other value—say, > data read from a keyboard—doesn’t that violate the assumption of RT > on monads? Monads provide a way to carry extra data or operations around with their values. IO passes an opaque "world state" around in the background, conceptually I/O operations modify the "world state" and it is in fact always valid to replace the monadified version with the unwrapped version --- ignoring IORefs, IO is just a simple state monad. The "world state" insures that operations in the IO monad are constrained to an ordered list. This gives us a referentially transparent *model* that behaves the way we need it to; the fact that actual I/O is not referentially transparent doesn't matter because the model insures that computations in IO behave properly. (Unless you use unsafePerformIO or unsafeInterleaveIO, which is why they're unsafe; you've violated the model, unexpected things can happen as a result.) -- brandon s. allbery [solaris,freebsd,perl,pugs,haskell] allbery(a)kf8nh.com system administrator [openafs,heimdal,too many hats] allbery(a)ece.cmu.edu electrical and computer engineering, carnegie mellon university KF8NH

11 28

Re: Referential Transparency and Monads
by Heinrich Apfelmus 11 Apr '09

11 Apr '09

Mark Spezzano wrote: > How exactly do monads “solve” the problem of referential transparency? I > understand RT to be such that a function can be replaced with a actual > value. > > Since a monad could potentially encapsulate any other value—say, data read > from a keyboard—doesn’t that violate the assumption of RT on monads? > > Or does RT ignore the encapsulated data and just view the “action” performed > by the monad as the “value” of the monad? The term "referential transparency" refers to functions and means that "equal arguments give equal results". For instance, there cannot be a function getChar :: () -> Char that reads input from the keyboard because referential transparency demands that the character returned must always be the same. Similarly, a function putChar :: Char -> () that prints a character on the screen cannot exist because we could replace every say putChar 'a' with () which does not output anything. Both values are equal, after all. However, functions getChar :: () -> IO Char putChar :: Char -> IO () are entirely feasible; the side effect has been pushed into the IO type constructor. In other words, getChar () :: IO Char is always the same IO action (reading a character from the keyboard) and putChar 'c' :: IO () is always the same IO action (printing 'c' on the screen). In other words, we have decomposed "function with side effect" = "pure function" + "side effect" -> + IO Regards, apfelmus -- http://apfelmus.nfshost.com

1 0

Trying to write 'safeFromInteger'
by Kannan Goundan 11 Apr '09

11 Apr '09

Here's my code (in file "Test.hs") safeFromInteger :: (Num a, Integral a, Bounded a) => Integer -> Maybe a safeFromInteger i = if i > (toInteger maxBound) then Nothing else Just (fromInteger i) Here's the error from GHCi 6.10.1: Test.hs:3:19: Ambiguous type variable `a' in the constraints: `Bounded a' arising from a use of `maxBound' at Test.hs:3:19-26 `Integral a' arising from a use of `toInteger' at Test.hs:3:9-26 Probable fix: add a type signature that fixes these type variable(s) It's almost like GHC thinks that the type variable "a" can't be part of the "Bounded" lass and the "Integeral" class. I plan to use "safeFromInteger" for converting from Word8, Word16, Word32, etc.

14 19

compilation related questions
by minh thu 11 Apr '09

11 Apr '09

Hi, There was a 'I want to write a compiler' thread recently. I wonder if there is such kind of pointers for compilation of strict functional languages (perhaps with lazy evaluation annotations) . Although GRIN is designed for lazy languages, would it be ok to use it for a strict one (and leverage its thunk representation for the lazy part of the language)? The 'whole program' optimization aspect is a plus. On a related note, I have another question. Say we have some data structure, for instance a list, some functions on this data structure (probably defined with some well known functions, such as map or fold), and a program using them. Is there any research trying to rewrite the program, and the data structure, to optimize them ? A contrived example is the length of a list : instead of traversing a list to know its length, the list can have an additional field which is incremented at each cons. Thanks, Thu

4 5

Ann: Yogurt-0.4
by Martijn van Steenbergen 11 Apr '09

11 Apr '09

Bonsoir café, It is my pleasure to announce version 0.4 of 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. Here is a small example of such a script: > module Minimal where > > import Network.Yogurt > > newmoon :: Session > newmoon = session > { hostName = "eclipse.cs.pdx.edu" > , portNumber = 7680 > , mudProgram = \reload -> do > mkCommand "reload" reload > } Valid scripts define at least one session which is used to connect to the MUD. mudProgram fields are provided with a reload action that when invoked reloads the script without interrupting the MUD connection. Of course, Yogurt also still offers hooks, timers, logging, variables and more. The executable is released as a separate package so that developers wishing to use just the "pure" machinery can do that without inheriting dependencies on the GHC API or readline library. To install the executable, run: $ cabal update $ cabal install Yogurt -freadline $ cabal install Yogurt-Standalone Yogurt's new home page can be found at: http://code.google.com/p/yogurt-mud/ And on hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Yogurt http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Yogurt-Standalone I would love to hear your feedback! Suggestions, complaints, comments, bug reports, experiences et cetera are all welcome. Kind regards, Martijn.

1 0

[Haskell-cafe] Paper: Translating donotation to SQL, Leijden, Meijer
by Günther Schmidt 11 Apr '09

11 Apr '09

Hi all, is the paper "Translating donotation to SQL, Leijden, Meijer (1999)" available anywhere? Günther

3 3

Re: [Haskell-cafe] Sequence differences
by michael rice 11 Apr '09

11 Apr '09

Clearly, I have some reading to do. Thanks, Michael --- On Fri, 4/10/09, Ketil Malde <ketil(a)malde.org> wrote: From: Ketil Malde <ketil(a)malde.org> Subject: Re: [Haskell-cafe] Sequence differences To: "michael rice" <nowgate(a)yahoo.com> Cc: "haskell Cafe mailing list" <haskell-cafe(a)haskell.org>, "Joe Fredette" <jfredett(a)gmail.com> Date: Friday, April 10, 2009, 3:52 PM michael rice <nowgate(a)yahoo.com> writes: > map :: (a -> b) -> [a] -> [b] <== I'm assuming this is correct This is the type of 'map', yes. Btw, ou can check types in GHCi with the :i command. > s f ls > > seems much like > > map f ls > > but instead looks like > > s :: (a -> a -> a) -> [a] -> [a] If you look at the definition: >> s f [] = [] >> s f [x] = [x] >> s f l = [ a f b | (a,b) <- zip (init l) (tail l)] You'll notice that the second clause, namely s f [x] = [x] produces the second parameter [x] (of type [a]) as its output, and thus the types must be the same as well. Also (assuming it is 'f a b' and not 'a f b' in the list comprehension), f is applied to two parameters, so it'll have to be of type (x -> y -> z), and since the two input parameters come from the originating list, x and y must be the same as a, and since we have seen the result list also has the same type, z must be the same as a, too. Thus f must have type (a -> a -> a). Unclear? Clear? Operating thetan? -k -- If I haven't seen further, it is by standing in the footprints of giants

1 0

Re: [Haskell-cafe] Re: Sequence differences
by michael rice 11 Apr '09

11 Apr '09

Yes, that is nice, and also useful for calculating moving averages. Thanks. Michael --- On Fri, 4/10/09, Chad Scherrer <chad.scherrer(a)pnl.gov> wrote: From: Chad Scherrer <chad.scherrer(a)pnl.gov> Subject: [Haskell-cafe] Re: Sequence differences To: haskell-cafe(a)haskell.org Date: Friday, April 10, 2009, 12:04 PM Joe Fredette <jfredett <at> gmail.com> writes: > We can write your original function in another, cleaner way though, too, > since zip will "zip" to the smaller of the two lengths, so you don't > need to worry about doing the init and the tail, so `s` is really: > > s _ [] = [] > s _ [x] = [x] > s f ls = [f a b | (a,b) <- zip ls (tail ls)] > > but there is a function which does precisely what the third case does, > called "zipWith" which takes a > binary function and two lists and -- well -- does what that list > comprehension does. In fact, it does > what your whole function does... In fact, it _is_ your function, > specialized a little, eg: > > yourZipWith f ls = zipWith f ls (tail ls) A nice generalization of this that can be really useful is movingWindow :: Int -> [a] -> [[a]] movingWindow 1 xs = map (:[]) xs movingWindow n xs = zipWith (:) xs . tail $ movingWindow (n-1) xs So for example, > movingWindow 3 [1..10] [[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,7],[6,7,8],[7,8,9],[8,9,10]] Then you can write diff :: (Num a) => [a] -> [a] diff = map (\[x,y] -> y - x) . movingWindow 2 Hopefully the intermediate lists are optimized away, but I haven't done any performance testing. Chad _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Re: [Haskell-cafe] Sequence differences
by michael rice 11 Apr '09

11 Apr '09

All very neat, and it works! Thanks. But I copied map :: (a -> b) -> [a] -> [b] <== I'm assuming this is correct from something called "A Tour of the Haskell Prelude" at http://undergraduate.csse.uwa.edu.au/units/CITS3211/lectureNotes/tourofprel… which I was looking at to try and roll my own typing. My next question: My function s f ls seems much like map f ls but instead looks like s :: (a -> a -> a) -> [a] -> [a] Clearly, there's more to the picture than meets the eye. Is there a good tutorial on types? Michael --- On Fri, 4/10/09, Joe Fredette <jfredett(a)gmail.com> wrote: From: Joe Fredette <jfredett(a)gmail.com> Subject: Re: [Haskell-cafe] Sequence differences To: "michael rice" <nowgate(a)yahoo.com>, "haskell Cafe mailing list" <haskell-cafe(a)haskell.org> Date: Friday, April 10, 2009, 2:07 AM So, we can walk through it- > s f [] = [] > s f [x] = [x] > s f l = [ a f b | (a,b) <- zip (init l) (tail l)] First, we can write some of it to be a little more idiomatic, viz: s _ [] = [] s _ [x] = [x] s f ls = [f a b | (a,b) <- zip (init ls) (tail ls)] First, we have a function type, we can tell the variable f is a function because it's applied to arguments in the third case, since it's applied to two arguments, it's binary, so `s :: (a -> b -> c) -> ?` however, from the second case, we know that whatever the type of the second argument (a list of some type `a1`) is also the type of the return argument, since the `s` acts as the identity for lists of length less than 2, so s :: (a -> b -> a1) -> [a1] -> [a1] However, since the arguments for `f` are drawn from the same list, the argument types must _also_ be of type `a1`, leaving us with: s :: (a -> a -> a) -> [a] -> [a] This is, interestingly enough, precisely the type of foldr1. We can write your original function in another, cleaner way though, too, since zip will "zip" to the smaller of the two lengths, so you don't need to worry about doing the init and the tail, so `s` is really: s _ [] = [] s _ [x] = [x] s f ls = [f a b | (a,b) <- zip ls (tail ls)] but there is a function which does precisely what the third case does, called "zipWith" which takes a binary function and two lists and -- well -- does what that list comprehension does. In fact, it does what your whole function does... In fact, it _is_ your function, specialized a little, eg: yourZipWith f ls = zipWith f ls (tail ls) Hope that helps /Joe michael rice wrote: > I have a Scheme function that calculates sequence differences, i.e., it returns a sequence that is the difference between the 2nd and the 1st element, the 3rd and the 2nd, the 4th and the 3rd, etc. > > (define s > (lambda (f l) > (cond ((null? (cdr l)) '()) > (else (cons (f (cadr l) (car l)) > (s f (cdr l))))))) > > where > > (s - '(0,1,3,6,10,15,21,28)) => (1,2,3,4,5,6,7) > > > I'm thinking the same function in Haskell would be something like > > s :: > s f [] = [] > s f [x] = [x] > s f l = [ a f b | (a,b) <- zip (init l) (tail l)] > > > but can't figure out what the function typing would be. > > Michael > > > ------------------------------------------------------------------------ > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

5 4

Re: [Haskell-cafe] Sequence differences
by michael rice 11 Apr '09

11 Apr '09

No, I was unaware of this, but it looks good. Thanks. Michael --- On Fri, 4/10/09, Martijn van Steenbergen <martijn(a)van.steenbergen.nl> wrote: From: Martijn van Steenbergen <martijn(a)van.steenbergen.nl> Subject: Re: [Haskell-cafe] Sequence differences To: "michael rice" <nowgate(a)yahoo.com> Cc: "haskell Cafe mailing list" <haskell-cafe(a)haskell.org>, "Joe Fredette" <jfredett(a)gmail.com> Date: Friday, April 10, 2009, 11:38 AM Hi Michael, michael rice wrote: > Clearly, there's more to the picture than meets the eye. Is there a good tutorial on types? Have you seen Real World Haskell? http://book.realworldhaskell.org/read/ Chapter 2 already dives into types. Hope this helps, Martijn.

1 0

Re: [Haskell-cafe] Referential Transparency and Monads
by Jason Dusek 10 Apr '09

10 Apr '09

2009/04/09 Mark Spezzano <mark.spezzano(a)chariot.net.au>: > How exactly do monads “solve” the problem of referential transparency? I > understand RT to be such that a function can be replaced with a actual > value. With referential transparency, an **expression** can be replaced with an evaluated variant of itself. When we choose to do the evaluation is not important. So we have some function: f :: SomeType -> SomeOther -> YetAnother -> SomethingElse One time, when we encounter `f a b c` and evaluate it to get `d`. Now whenever we see `f a b c` again, referential transparency tells us we can just stick the `d` right there and not bother about running the program that is inside `f`. What you have with the IO monad is things that look like the same expression but actually aren't; you also have rules of evaluation that force the reduction strategy to reduce things in order. Consider this: main = do c0 <- getChar c1 <- getChar print c1 At first glance, Pooh (or even Owl) might say, "The first `getChar` is just the same as the second.". Doesn't referential transparency say that we should just evaluate it one time and thus get only the first character in the stream? Well, no. Doesn't laziness say, we only need `c1` so we'll just read the first character off the stream? No again. The do notation is a great convenience; it is syntax transformed to this: main = getChar >>= (\c0 -> (getChar >>= (\c1 -> print c1))) We see right away that, in order to get at the second `getChar`, we need to provide an argument to the first lambda. Likewise, to get at the `print`, we need to provide an argument to the second lambda. The `>>=` is called "bind" and plays an essential role here. Each monad has its own bind -- bind is an integral part of its evaluation strategy. Let us consider a simplified implementation of the IO monad: data World = World ... data IO t = IO (World -> (t, World)) Every value of type `IO t` contains a function that takes us from `World` to a pair of `World` and `t`. The `World` is not important beyond the notion that no two are alike. Our implementation of `>>=` (also simplified compared to a real one): >>= :: IO a -> (a -> IO b) -> IO b IO act1 >>= f = IO (\w1 -> let { (t, w2) = act1 w1 ; IO act2 = f t } in act2 w2) Then we have `getChar` and `print`: getChar = IO charOp {- `charOp` is some unsafe operation that does the getting. -} print something = IO (printOp something) {- `printOp` is some unsafe operation that does the printing. -} Now let's substitute that into the above and see what we get: main = getChar >>= (\c0 -> (getChar >>= (\c1 -> print c1))) main = IO charOp >>= (\c0 -> (getChar >>= (\c1 -> print c1))) main = IO (\w1 -> let (c, w2) = charOp w1 IO act2 = (\c0 -> (getChar >>= (\c1 -> print c1))) c in act2 w2 ) main = IO (\w1 -> let (c, w2) = charOp w1 IO act2 = (getChar >>= (\c1 -> print c1)) in act2 w2 ) Let's work on just `act2`: IO act2 = (getChar >>= (\c1 -> print c1)) IO act2 = (IO charOp >>= (\c1 -> print c1)) IO act2 = IO (\w -> let (c', w3) = charOp w IO act3 = (\c1 -> print c1) c' in act3 w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w IO act3 = print c' in act3 w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w IO act3 = IO (printOp c') in act3 w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w in (printOp c') w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w in (printOp c') w3) Substituting: main = IO (\w1 -> let (c, w2) = charOp w1 IO act2 = IO (\w -> let (c', w3) = charOp w in (printOp c') w3) in act2 w2 ) main = IO (\w1 -> let (c, w2) = charOp w1 in (\w -> let (c', w3) = charOp w in (printOp c') w3) w2 ) main = IO (\w1 -> let (c, w2) = charOp w1 in let (c', w3) = charOp w2 in (printOp c') w3 ) So we let's review. Are the two `getChar`s the same expression? No -- one is called against one world, the other against another. Furthermore, they are ordered -- we need the world from the first one to get the world from the second. We need the second world to `print`. This is guaranteed by the semantics of "bind" in the IO monad. The expressions are not the same so referential transparency does not does not lead to dangerous elision; the data dependencies are explicit and so there is no way to re-order the evaluation of the expressions. Notice that these properties fall out of our rules for evaluation and not any "special sauce" for monads. > Just curious as to the rationale behind referential > transparency and how it applies to monads. That depends on the monad. -- Jason Dusek

1 0