August 2007 - Haskell-Cafe

FW: RE [Haskell-cafe] Monad Description For Imperative Programmer
by peterv 08 Aug '07

08 Aug '07

Kaveh> "A monad is like a loop that can run a new function against its variable in each iteration." I’m an imperative programmer learning Haskell, so I’m a newbie, but I’ll give it a try ☺ Making mistakes is the best way to learn it ;) There are lots of different kinds of monads, but let’s stick to the IO monad first, which you seem to refer to. No *an IO monad is not a loop at all*. Instead, from an imperative programmer’s point of view, the following might be better: “an IO monad is a delayed action that will be executed as soon as that action is needed for further evaluation of the program.” The simple program main = getLine >>= putStrLn can be visually represented as (see attachment) The “world” (=a representation of your computer’s hardware) is passed to the main function, which passes it to all actions that it encounters during its lazy evaluation, causing the executing of the actions as an effect. The red wire through which the “world flows” is a “single thread”, it cannot be split (because the physical world cannot be copied!!!), so no unwanted side effects can ever occur, making IO safe in Haskell. When you write your IO program, this world object is never available (the IO type is a special internal type), so the red wire is erased from the diagram, and the getLine and putStrLn boxes become “delayed actions”. Imperative programmers like myself might initially be confused when they see Haskell’s do notation, because it looks like the actions are strict statements as in C/C++/Pascal/Java/C#/etc, but they are not. For example, try the following program: main = do last [ putStrLn "NOT executed although it is first in the list, as it is not used by the main function!", putStrLn "This action IS executed because it is evaluated by the main function." ] This is of course all due to Haskell’s laziness which only evaluates just those expressions that it needs to evaluate the main function. One thing to note in the diagram above is that the getLine box has TWO outputs, the String and the World. But functions can only have a single output, but this can be tuple. Hence the passing of the world from one box to the other is a bit more complicated. It is this pattern of extracting both values from the output and passing them to the next function and other related combinations that form the generic monad class, which can be used for many more things than IO. See http://haskell.org/haskellwiki/IO_inside for a much deeper and more correct explanation ☺ And for the pros here, did this newbie make any sense? Probably not ;-) Oh no, yet another monad explanation!!! Now the universe will most certainly collapse… No virus found in this outgoing message. Checked by AVG Free Edition. Version: 7.5.476 / Virus Database: 269.11.0/929 - Release Date: 31/07/2007 17:26

15 23

Bug in GHCi?
by Dusan Kolar 08 Aug '07

08 Aug '07

Hello all, Maybe this is a wrong place to report, but I have repeatedly performed "funny" calculation in GHCi with strange time report. The version of GHCi is: ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. Prelude> My machine: OS WinXP Pro SP2, Intel Core 2, 2GB RAM. How to reproduce error: :set +s :set -02 :cd <path to the file in the attachment> :l Primes take 10000 primes1 <provides correct result and shows correct timing, about 636 seconds> take 10000 primes2 <provides correct result, BUT INCORRECT TIMING - about -326 seconds> Yes, that is not a typo. The report of time elapsed is: minus three hundred and twenty six seconds. I'll try the newest version of the GHCi, but it is strange anyway and maybe it should be investigated... Thanks, Dusan module Primes ( primes1 ,primes2 ,primes3 ,primes2' ,primes3' ) where candidates = map (\x -> (True,x)) [2..] candidates' = [2..] skipmap f toSkip list = domap toSkip list where domap n (x:xs) | n > 1 = x : domap (n-1) xs | True = f x : domap toSkip xs domap _ [] = [] primes1 = sieve candidates where sieve (pp@(isp,p):xs) | isp = p : (sieve $ skipmap (\(_,v) -> (False,v)) p xs) | True = sieve xs primes1' = sieve candidates' where sieve (p:xs) | p > 0 = p : (sieve $ skipmap (\n -> if n>0 then (-n) else n) p xs) | True = sieve xs sieve (p:xs) = p : sieve [y | y <- xs, y `mod` p /= 0] sieve' (p:xs) = p : sieve [y | y <- xs, y `mod` p > 0] primes2 = sieve [2..] primes3 = 2 : sieve [3,5..] primes2' = sieve' [2..] primes3' = 2 : sieve' [3,5..]

1 0

OS swapping and haskell data structures
by Alex Jacobson 08 Aug '07

08 Aug '07

If you create a Data.Map or Data.Set larger than fits in physical memory, will OS level swapping enable your app to behave reasonably or will things just die catastrophically as you hit a memory limit? -Alex-

6 7

creating graphics the functional way
by Frank Buss 08 Aug '07

08 Aug '07

I've created a small program to compose images with combinators: http://www.frank-buss.de/haskell/OlympicRings.hs.txt It produces TGA output, but I've converted it to PNG, because this is smaller: http://www.frank-buss.de/haskell/OlympicRings.png This is my first larger Haskell program and I have some questions: Nearly anything works without thinking too much about the types, but I don't like the use of fromInteger in the average and main functions. Is it possible that the integers are automaticly converted to floats? There are many functions like circle1Center, circle2Center, ... Is it possible to rewrite the program that it will be shorter, maybe using lists or an interpreter for a language for this kind of combinator programming style? Is it possible to write functions with an arbitrary number of arguments? Would be nice if the average function would accept any number of pixel values. Is there a PNG writer library for Haskell? I've seen a zlib interface, should be not too difficult to implement it in Haskell itself. Finally, what do you think about using this concept for generating images? It has some advantages, e.g. it is possible to scale the image without quality loss. But it needs some improvement, e.g. the anti-aliasing doesn't look very smooth. And it is very slow, it needs about 40 seconds on my computer to calculate the image. Using parametrized combinators sounds like a good idea for an interactive interface, like it is implemented in this program: http://www.theprodukkt.com/werkkzeug1#28 But this is impossible, if changing one parameter needs so long to update the image. -- Frank Buss, fb(a)frank-buss.de http://www.frank-buss.de, http://www.it4-systems.de

8 13

Type classes: Missing language feature?
by DavidA 07 Aug '07

07 Aug '07

Hi, there's something I'm trying to do with type classes that seems to fit very naturally with my mental model of type classes, but doesn't seem to be supported by the language. I'm wondering whether I'm missing something, or whether there's some language extension that could help me or alternative way of achieving what I'm trying to achieve. I'm trying to define multivariate polynomials, which are sums of monomials - for example x^2y + z^4. In algorithms on multivariate polynomials, one typically wants to support different monomial orders. For example, the lex order is dictionary order - xxy < xy < y < yyy - whereas the graded lex (glex) order also takes into account the degree of the monomials - y < xy < xxy < yyy. Here's some code (based on http://sigfpe.blogspot.com/2007/07/ill-have- buchburger-with-fries.html): import Data.Map as M import Data.List as L newtype Monomial = Monomial (Map String Int) deriving (Eq) x = Monomial $ singleton "x" 1 y = Monomial $ singleton "y" 1 instance Show Monomial where show (Monomial a) = concatMap (\(v,i)-> v ++ "^" ++ show i) $ toList a -- simplified for brevity instance Num Monomial where Monomial a * Monomial b = Monomial $ unionWith (+) a b newtype Lex = Lex Monomial deriving (Eq) newtype Glex = Glex Monomial deriving (Eq) instance Ord Lex where Lex (Monomial m) <= Lex (Monomial m') = toList m <= toList m' instance Ord Glex where Glex (Monomial m) <= Glex (Monomial m') = (sum $ elems m, toList m) <= (sum $ elems m', toList m') Now, what I'd like to do is have Lex and Glex, and any further monomial orderings I define later, automatically derive Show and Num instances from Monomial (because it seems like boilerplate to have to define Show and Num instances by hand). Something like the following (not valid Haskell): class OrdMonomial m where fromRaw :: Monomial -> m toRaw :: m -> Monomial instance OrdMonomial Lex where fromRaw m = Lex m toRaw (Lex m) = m instance OrdMonomial Glex where fromRaw m = Glex m toRaw (Glex m) = m derive OrdMonomial m => Show m where show m = show (toRaw m) derive OrdMonomial m => Num m where m * m' = fromRaw (toRaw m * toRaw m') Is there a way to do what I'm trying to do? (Preferably without resorting to template Haskell, etc) - It seems like a natural thing to want to do.

4 3

Haskell Weekly News: August 07, 2007
by dons＠cse.unsw.edu.au 07 Aug '07

07 Aug '07

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20070807 Issue 64 - August 07, 2007 --------------------------------------------------------------------------- Welcome to issue 64 of HWN, a weekly newsletter covering developments in the [1]Haskell community. This issue marks the second anniversary of the Haskell (not quite) Weekly News. Thanks to the Haskell community for support, content and for reading over the last two years! 1. http://haskell.org/ Announcements OSCON Haskell Tutorial. Simon Peyton-Jones Appeared at the O'Reilly Open Source Convention (OSCON) in Portland, delivering a range of talks, including [2]A Taste of Haskell, [3]A Keynote on Functional Languages, [4]Nested Data Parallelism and [5]Transactional Memory for Concurrent Programming. Videos are available for most of these talks: [6]A Taste of Haskell: Part 1, [7]A Taste of Haskell: Part 2, [8]slides for A Taste of Haskell, [9]Transactional Memory for Concurrent Programming and [10]the NDP talk at the London Hugs meeting. 2. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14016 3. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14773 4. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14014 5. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14017 6. http://blip.tv/file/324976 7. http://www.blip.tv/file/325646/ 8. http://conferences.oreillynet.com/presentations/os2007/os_peytonjones.pdf 9. http://www.blip.tv/file/317758/ 10. http://video.google.co.uk/videoplay?docid=370317485066035666 hpodder 1.0. John Goerzen [11]announced version 1.0.0 of hpodder, the command-line podcatcher (podcast downloader) that just happens to be written in everyone's favorite language. You can get it [12]here. Version 1.0.0 sports a new mechanism for detecting and disabling feeds or episodes that repeatedly result in errors, updates to the Sqlite database schema, and several bugfixes. 11. http://article.gmane.org/gmane.comp.lang.haskell.general/15452 12. http://software.complete.org/hpodder encoding-0.1. Henning Günther [13]announced the release of 'encoding', a Haskell library to cope with many character encodings found on modern computers. At the moment it supports (much more is planned): ASCII, UTF-8, -16, -32, ISO 8859-* (alias latin-*), CP125* (windows codepages), KOI8-R, Bootstring (base for punycode) 13. http://article.gmane.org/gmane.comp.lang.haskell.general/15481 Dimensional 0.6: Statically checked physical dimensions. Björn Buckwalter [14]announced a library providing data types for performing arithmetic with physical quantities and units. Information about the physical dimensions of the quantities/units is embedded in their types and the validity of operations is verified by the type checker at compile time. The boxing and unboxing of numerical values as quantities is done by multiplication and division with units. 14. http://article.gmane.org/gmane.comp.lang.haskell.cafe/26944 Hackage This week's new libraries in [15]the Hackage library database. * hgal-1.0.1. Jean Philippe Bernardy. [16]Computation automorphism group and canonical labeling of a graph * hpodder-1.0.3. John Goerzen. [17]Podcast Aggregator (downloader) * dlist-0.3.1. Don Stewart. [18]Differences lists: a list-like type supporting O(1) append * pointfree-1.0. Felix Martini. [19]Stand-alone command-line version of the point-less plugin for lambdabot * encoding-0.1. Henning Guenther. [20]A library for various character encodings * AppleScript-0.1.3. Wouter Swierstra. [21]Call AppleScript from Haskell * SDL-ttf-0.4.0. David Himmelstrup. [22]Binding to libSDL_ttf * Finance-Quote-Yahoo-0.2. Brad Clawsie. [23]Obtain quote data from finance.yahoo.com * xmobar-0.7. Andrea Rossato. [24]A Minimalistic Text Based Status Bar 15. http://hackage.haskell.org/ 16. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hgal-1.0.1 17. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hpodder-1.0.3 18. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/dlist-0.3.1 19. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/pointfree-1.0 20. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/encoding-0.1 21. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/AppleScript-0.1.3 22. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/SDL-ttf-0.4.0 23. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Finance-Quote-Ya… 24. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmobar-0.7 Conference roundup OSCON. Simon Peyton-Jones gave a series of popular talks about Haskell and functional programming at OSCON, in Portland. Below are collected just some of the posts about Haskell at OSCON. * [25]A brief Haskell-at-OSCON trip report * [26]Wow! OSCON video viewing statistics * [27]OSCon Wednesday Part 2 * [28]A Taste of Haskell, A Taste of C * [29]OSCON Day 1 * [30]A Taste of Haskell * [31]OSCON 2007 * [32]Threading Building Blocks and C++ * [33]OSCON: Wednesday Morning * [34]OSCON: Wednesday Afternoon * [35]OSCON 2007 (July 25) * [36]Nested Data Parallelism in Haskell * [37]OSCON 2007: Wednesday Morning Keynotes * [38]A Taste of Haskell 25. http://www.realworldhaskell.org/blog/2007/08/03/a-brief-haskell-at-oscon-tr… 26. http://www.realworldhaskell.org/blog/2007/08/07/wow-oscon-video-viewing-sta… 27. http://changelog.complete.org/posts/632-OSCon-Wednesday-Part-2.html 28. http://www.oreillynet.com/onlamp/blog/2007/07/a_taste_of_haskell_a_taste_of… 29. http://brycebaril.vox.com/library/post/oscon-2007-day-1.html 30. http://jaortega.wordpress.com/2007/08/04/a-taste-of-haskell/ 31. http://www.sauria.com/blog/2007/08/03/oscon-2007/ 32. http://softwareblogs.intel.com/2007/07/26/threading-building-blocks-and-c/ 33. http://znark.com/blog/2007/07/25/oscon-wednesday-morning 34. http://znark.com/blog/2007/07/25/oscon-wednesday-afternoon 35. http://panela.blog-city.com/oscon_2007_july_25.htm 36. http://ihack.us/2007/07/25/nested-data-parallelism-in-haskell/ 37. http://www.canspice.org/2007/07/25/oscon-2007-wednesday-morning-keynotes/ 38. http://butlerpress.com/2007/07/24/a-taste-of-haskell/ Blog noise [39]Haskell news from the [40]blogosphere. * [41]Ord, Countable Ordinals, and an Idea of sigfpe * [42]Word numbers, Part 1: Billion approaches * [43]Implementing SmallTalk in Haskell * [44]From walking to zipping, Part 1: Moving right * [45]From walking to zipping, Part 2: Down and up * [46]Irrefutable patterns for the ignorant * [47]Making Haskell nicer for game programming * [48]Nested Data Parallelism in Haskell * [49]Compiling Haskell to Erlang * [50]Peano's Axioms IV: Advanced Functions and Integers * [51]37 Reasons to Love Haskell * [52]On the value of strong static typing * [53]Parsec Parser Testing with QuickCheck * [54]Fallacies in the Great Dynamic vs Static Debate * [55]Implementing a dictionary using first class functions * [56]Strong specifications in Coq: the type says everything * [57]Run length encoding in Haskell * [58]Run length encoding and arrows * [59]Playing with Arrows * [60]Monads! (and Why Monad Tutorials Are All Awful) * [61]Haskell: Explaining Arrows through XML Transformations * [62]Monads as computation * [63]Closed Categories * [64]Good Haskell Style * [65]Monads are hard to teach * [66]Parsec * [67]First attempt at using GTK with Haskell * [68]Introduction to Haskell, Part 3: Monads * [69]Programming in Haskell * [70]Haskell Fun * [71]Algebraic Data Types again * [72]DFAs, Categories, and Typecheckers * [73]Haskell State Accessors (second attempt: Composability) * [74]Developing Programs and Proofs Spontaneously using GADT * [75]Encoding Inductive and Coinductive Types in Polymorphic Lambda Calculus * [76]Polymorphic Types in Haskell without Constructors? * [77]Subtraction not Definable in Simply Typed Lambda Calculus * [78]Imperative programming is a special type of functional programming * [79]Binding Haskell to C structs 39. http://planet.haskell.org/ 40. http://haskell.org/haskellwiki/Blog_articles 41. http://blog.jbapple.com/2007/07/ord-countable-ordinals-and-idea-of.html 42. http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers1/ 43. http://lstephen.wordpress.com/2007/07/23/completing-the-spike/ 44. http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip1/ 45. http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip2/ 46. http://therning.org/magnus/archives/311 47. http://luqui.org/blog/archives/2007/07/26/making-haskell-nicer-for-game-pro… 48. http://ihack.us/2007/07/25/nested-data-parallelism-in-haskell/ 49. http://blog.tornkvist.org/?id=1185571582964040 50. http://disparatemathematician.blogspot.com/2007/07/peanos-axioms-iv-advance… 51. http://cdsmith.wordpress.com/2007/07/29/37-reasons-to-love-haskell-playing-… 52. http://www.serpentine.com/blog/2007/07/29/on-the-value-of-strong-static-typ… 53. http://lstephen.wordpress.com/2007/07/29/parsec-parser-testing-with-quickch… 54. http://neilbartlett.name/blog/2007/07/30/fallacies-in-the-great-dynamic-vs-… 55. http://lukeplant.me.uk/blog.php?id=1107301671 56. http://www.rubrication.net/2007/04/24/strong-specifications/ 57. http://cgi.cse.unsw.edu.au/~dons/blog/2007/07/31#rle 58. http://community.livejournal.com/evan_tech/229752.html 59. http://unenterprise.blogspot.com/2007/08/playing-with-arrows.html 60. http://ahamsandwich.wordpress.com/2007/07/26/monads-and-why-monad-tutorials… 61. http://neilbartlett.name/blog/2007/08/01/haskell-explaining-arrows-through-… 62. http://www.haskell.org/haskellwiki/Monads_as_computation 63. http://unapologetic.wordpress.com/2007/08/01/closed-categories/ 64. http://urchin.earth.li/~ian/style/haskell.html 65. http://davblog48.blogspot.com/2007/08/monads-are-hard-to-teach.html 66. http://davblog48.blogspot.com/2007/05/parsec.html 67. http://davblog48.blogspot.com/2007/05/first-attempt-at-using-gtk-with-haske… 68. http://www.onlamp.com/pub/a/onlamp/2007/08/02/introduction-to-haskell-pure-… 69. http://www.cs.chalmers.se/Cs/Grundutb/Kurser/d1pt/d1pta/external.html 70. http://changelog.complete.org/posts/640-guid.html 71. http://blog.tmorris.net/algebraic-data-types-again/ 72. http://disparatemathematician.blogspot.com/2007/08/dfas-categories-and-type… 73. http://luqui.org/blog/archives/2007/08/05/haskell-state-accessors-second-at… 74. http://www.iis.sinica.edu.tw/~scm/?p=32 75. http://www.iis.sinica.edu.tw/~scm/?p=31 76. http://www.iis.sinica.edu.tw/~scm/?p=28 77. http://www.iis.sinica.edu.tw/~scm/?p=27 78. http://blog.tmorris.net/imperative-programming-is-a-special-type-of-functio… 79. http://therning.org/magnus/archives/315 Quotes of the Week * schluehk: ... Haskell taking over the world and troubled parents ask why their kids have turned into math hippies talking about nothing but love and abstract algebra... * JohnGoerzen: Haskell manipulates functions with the same ease that Perl manipulates strings * (anonymous Russian blogger): Glory to Simons! Glory to Swedish professors! * Laurent Sansonetti: I appreciated so much the Haskell talks that I am now learning the language. * dcoutts: Apparently that's only 200x faster than the faster of two common python serialisation libs, so we've got some way to go yet. * slava: [on Isabelle for web frameworks] IM IN UR WEB SITEZ, CODING PROVABLY-CORRECT BLINK TAG!! * gimboland: At present i'd say 'tinkering with a nuclear bomb' is approximately where i am with monads... * jcreigh: Could not find instance Ord for type ProgrammingLanguage * kowey: i suspect we're one of the rare wikibooks to use higher order templates * monochrom: 'm a -> (a -> m b) -> m b' is much more to the point than 'mumble computation mumble computation mumble computation mumble' * roconnor: damn it, Haskell pseudo code is indistinguishable from actual code * slava: Because top enterprise industry analysts recommend Because top enterprise industry analysts recommend that managers need to focus on Agile methodologies, SOA, B2B and Yoneda's lemma in today's rich internet application-driven environment. Don't get left behind by the AJAX craze by missing out on call center outsourcing and Yoneda's lemma! Code Watch Notable new features and bug fixes to the Haskell compilers. Fri Jul 27 03:41:57 PDT 2007. Simon Marlow. Pointer Tagging. This patch implements pointer tagging as per our ICFP'07 paper 'Faster laziness using dynamic pointer tagging'. It improves performance by 10-15% for most workloads, including GHC itself. The original patches were by Alexey Rodriguez Yakushev, with additions and improvements by me. I've re-recorded the development as a single patch. The basic idea is this: we use the low 2 bits of a pointer to a heap object (3 bits on a 64-bit architecture) to encode some information about the object pointed to. For a constructor, we encode the 'tag' of the constructor (e.g. True vs. False), for a function closure its arity. This enables some decisions to be made without dereferencing the pointer, which speeds up some common operations. In particular it enables us to avoid costly indirect jumps in many cases. More information [80]in the commentary. 80. http://hackage.haskell.org/trac/ghc/wiki/Commentary/Rts/HaskellExecution/Po… About the Haskell Weekly News Each week, new editions are posted to [81]the Haskell mailing list as well as to [82]the Haskell Sequence and [83]Planet Haskell. [84]RSS is also available, and headlines appear on [85]haskell.org. Headlines are available as [86]PDF. To help create new editions of this newsletter, please see the [87]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get [88]http://www.cse.unsw.edu.au/~dons/code/hwn 81. http://www.haskell.org/mailman/listinfo/haskell 82. http://sequence.complete.org/ 83. http://planet.haskell.org/ 84. http://sequence.complete.org/node/feed 85. http://haskell.org/ 86. http://www.cse.unsw.edu.au/~dons/code/hwn/archives/20070807.pdf 87. http://haskell.org/haskellwiki/HWN 88. http://www.cse.unsw.edu.au/~dons/code/hwn

1 0

Monad for Set?
by Ronald Guida 07 Aug '07

07 Aug '07

Hi, I'm pondering, is it possible to define a Set monad analogous to the List monad? My thinking is as follows: * "fmap f x" would apply f to each element in a set x * "return x" would create a singleton set {x} * "join x", where x is a set of sets: x = {x1, x2, ... xn}, would form their union (x1 U x2 U ... U xn) The advantage of Set over List is that duplicate elements would be removed automatically. There is just one /slight/ problem: In order to implement set operations, I need to be able to test elements for equality; that is, I need to impose the restriction (Eq a) => Set a. This is a problem because return really needs to work for any type; I have no way to guarantee (Eq a). In my search for answers, I came across "restricted monads". I don't like the idea of restricting the types I can return, and here's why. Suppose I had a way to impose (Eq a). Then I start to wonder: * What happens when I use a monad transformer like "StateT s Set a" or "ContT r Set a", but the types s and r are not equatable? * What happens when I want to define the monad transformer SetT because I need to put the IO monad inside it? In both cases, I feel I'm screwed if I really have to impose the constraint (Eq a) => Set a. This leads me think of a different solution: What if I could define a Set monad that's smart enough to "know", for any type a, whether or not (Eq a) holds, and degenerate to a blind list if the elements can't be equated. Ultimately, what I would need is a way to overload "join" (or "bind") with two different implementations, one for types that satisfy (Eq a), and another implementation for all other types. In my searching so far, I found ways to overload a function when all overloads share a common typeclass, and I have found ways to overload a function for disjoint types, provided that every type to be overload is an instance of some typeclass. All of the methods I have found so far are deficient in the sense that there is no way to provide a default implementation for types that don't fit into any typeclass. I have not been able to find a way to overload a function such that one implementation works for a special class of types, and another implementation works for *all* other types. Question: Is it possible to define join :: [[a]] -> [a], with (1) a special implementation that requires (Eq a) and removes duplicate elements, and (2) a general implementation to fall back on for *any* type that fails the constraint, and (3) a way to make "f" fully generic, such that the correct implementation is chosen automatically from the type variable a? If I had a way to do this, then I could define a Set monad that performs set operations when it can (i.e. when the elements are equatable), but which automatically degenerates to a simple List when it has to (i.e. when there's no equality test). I almost suspect that I might need to use Haskell Templates (I currently know nothing about Haskell Templates). Even better, if this problem is solvable, then the next step would be to overload again to use an efficient implementation when set elements are comparable (Ord a). Any ideas? -- Ron

3 2

Any ideas how to go about doing a phd in threading?
by Hugh Perkins 07 Aug '07

07 Aug '07

Hi, Really interested in doing a phd on threading. Any ideas how I'd go about doing/applying for that? Basically, threading seems to be the cutting-edge right out (for a while) as processor frequencies top out, and multicores increase. I dont have any formal CS training, but I do have a degree in natsci from Cambridge, quite a few years experience in industry, and anyone who knows me can attest that I'm highly motivated; a string of opensource work shows that I'm more interested in having fun than earning money, for a geek's definition of having fun :-) No particular preference for language, whatever it takes ;-) The Haskell group seems to have a high percentage of phds, and Haskell is a candidate language for automatic thread management, so seems an appropriate group to ask about this? Here's my cv in case it's useful: http://manageddreams.com/CV_PERKINS.pdf

1 0

Newbie question: "multi-methods" in Haskell
by peterv 07 Aug '07

07 Aug '07

In de book Modern C++ design, Andrei Alexandrescu writes that Haskell supports “multi-methods” http://books.google.com/books?id=aJ1av7UFBPwC&pg=PA3&ots=YPiJ_nWi6Y&dq=moder n+C%2B%2B&sig=FWO6SVfIrgtCWifj9yYHj3bnplQ#PPA263,M1 How is this actually done in Haskell? Maybe this is just a basic feature of Haskell which I don't grasp yet because of my object-oriented background? A good example is collision between pairs of objects of type (a,b). In object oriented languages this cannot be handled in a nice way, because neither a.Collide(b) or b.Collide(a) is the correct approach; one would like to write (a,b).Collide() A specific example might be better here. Assume the following class hierarchy: Solid | +-- Asteroid | +-- Planet | + -- Earth | + -- Jupiter Using multi-methods, I could write (in pseudo code) collide (Asteroid, Planet) = "an asteroid hit a planet" collide (Asteroid, Earth) = "the end of the dinos" collide (Solid,Solid) = " solids collided" collide (Planet, Asteroid) = collide (Asteroid, Planet) collide (Earth, Asteroid) = collide (Earth, Asteroid) So basically, the "best" collide function is picked, depending on the type of the arguments. How should I write Haskell code for something like this in general, in the sense that this hierarchy is typically huge and the matrix (of collide functions for each pair of types) is very sparse. Thanks, Peter No virus found in this outgoing message. Checked by AVG Free Edition. Version: 7.5.476 / Virus Database: 269.11.6/938 - Release Date: 05/08/2007 16:16

5 7

combinators for a simple grammar
by Rahul Kapoor 07 Aug '07

07 Aug '07

I am having problems coming up with nice combinators for a simple DSEL. The abstract syntax is simply given by the types: data SearchCondition = SearchCondition BoolTerm | OpOr SearchCondition BoolTerm data BoolTerm = BoolTerm BoolFactor | OpAnd BoolTerm BoolFactor data BoolFactor = Constant Bool My current combinators are (.||.) :: SearchCondition -> BoolTerm -> SearchCondition (.||.) sc term = OpOr sc term (.&&.) :: BoolTerm -> BoolFactor -> BoolTerm (.&&.) term fact = OpAnd term fact which allow you to write expression of the form factTrue = Constant True termTrue = BoolTerm factTrue scTrue = SearchCondition termTrue sc = scTrue .||. termTrue .||. termTrue .&&. factTrue I am wondering it it is possible to define combinators to hide the structure of the grammar from the user to some extent, so that the user can simply write things like sc = True .||.True .||. True .&&. False or sc = const True .||. const True .||. const True .&&. const False That is the user does not have to worry about the distinction between terms and factors (which exists solely for precedence in this case). Or is it a better idea to just remove the precedence rules from the types and move it the part of the code that evaluates the expressions? Rahul

3 2