- Haskell-Cafe - Haskell.org

Re: [Haskell] Re: Newbie: what are the advantages of Haskell?
by Rafael 30 Apr '07

30 Apr '07

I'll study these ways to debugging Haskell, and in accordance with my final work plan I'll decide the better way to follow.. For the moment i'm studing Haskell things, but in the next times I'll might decide it. A lot of thanks Neil and Simon. On 4/30/07, Simon Marlow <simonmarhaskell(a)gmail.com> wrote: > Rafael wrote: > >> Hi > >> > >> HTTP. We also need better availability of libraries, and a more > >> standard and reliable way to install them and specify their > >> dependencies. We could also do with a good debugger. These are being > >> addressed by the Google Summer of Code project. > > > > Hi Neil, a good debugger ? What is in Google Summer of Code about it ? > > > > I just found it: > > http://hackage.haskell.org/trac/summer-of-code/ticket/6 > > that havent student related. > > > > I was studing about debuging techs for haskell to build a nice > > debugging enviorment in HIDE or some other IDE. It's my bacharelor > > final work. > > We're building some debugging features into GHCi. This started with Pepe > Iborra's Summer of Code project last year, and more recently Bernie Pope > reworked the breakpoint support during his internship here at MSR Cambridge. We > are actively working on polishing what we have for inclusion in the next major > GHC release. > > The GHCi debugger is based on imperative debugging techniques: breakpoints, > single stepping, etc. It's a live debugger rather than post-mortem. We > focussed on accessibilty, rather than functionality: so the debugger is always > on, and it works with everything that you can compile in GHCi. It lacks some of > the advanced debugging features you'll find in Hat, for example, but we hope it > makes up for that by being more broadly accessible. > > More information on the debugger is here: > > http://hackage.haskell.org/trac/ghc/wiki/NewGhciDebugger > > although note that development is ongoing and more features have been added > since the wiki was last updated. > > All the debugging functionality is exposed by the GHC API, so it's certainly > possible to build debugging support into an IDE based on GHC. > > Cheers, > Simon >

1 0

ANN: The Monad.Reader - Issue7
by Wouter Swierstra 30 Apr '07

30 Apr '07

I am pleased to announce that the latest issue of The Monad.Reader is now available: http://www.haskell.org/haskellwiki/The_Monad.Reader Issue 7 consists of the following four articles: * Matthew Naylor A Recipe for controlling Lego using Lava * Yaron Minsky Caml Trading: Experiences in Functional Programming on Wall Street * Duncan Coutts Book Review: “Programming in Haskell” by Graham Hutton * Dimitry Golubovsky, Neil Mitchell, Matthew Naylor Yhc.Core – from Haskell to Core The Monad.Reader is a quarterly magazine about functional programming. It is less-formal than journal, but somehow more enduring than a wiki page or blog post. If you'd like to submit something to the next issue of The Monad.Reader, please get in touch. I haven't fixed the deadline for the next issue just yet; I hope to send out an official call for copy in the coming weeks. Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

COM and Haskell
by Justin Bailey 30 Apr '07

30 Apr '07

All, I'm interested in automating Excel using Haskell. I'm writing a little program for my wife and it'd be nice to fill out an Excel spreadsheet for her (with formatting so I don't think CSV will cut it). A bit of Googling didn't turn up anything interesting. Has any work been done on using Excel (or more generally, COM) from Haskell? Thanks for any pointers! Justin p.s. I'm aware of the article "Spreadsheet for Functional Programmers" article and Neil Mitchell's post about HsExcel - but those go the wrong way :(

14 18

PartitionBy (was: Behavior groupBy)
by Hans van Thiel 29 Apr '07

29 Apr '07

Hello All, As usual, my first attempt could be better.. -- partitions a list according to an equivalence relation import Data.List (partition) partitionBy :: (a -> a -> Bool) -> [a] -> [[a]] partitionBy eq [] = [] partitionBy eq ls = x:(partitionBy eq y) where (x,y) = partition ((head ls) `eq`) ls example> partitionBy (\x y -> (last x) == (last y)) ["abc","bd","bdc","abd"] result> [["abc","bdc"],["bd","abd"]] Of course, any crits would be appreciated, but maybe this will save somebody some time.. Thanks, Hans van Thiel

1 0

Re: [Haskell] Re: Newbie: what are the advantages of Haskell?
by Neil Mitchell 29 Apr '07

29 Apr '07

Moving to haskell-cafe@ ... > Hi Neil, a good debugger ? What is in Google Summer of Code about it ? Updating Hat, www.haskell.org/hat - see http://code.google.com/soc/haskell/about.html > I was studing about debuging techs for haskell to build a nice > debugging enviorment in HIDE or some other IDE. It's my bacharelor > final work. > > I and my teacher are thoughting about trying "observes" in a transparent way. > The user click and point to in a source local... but the observes dont > appear in the code. We will try integrate another technique from HAT > in this imaginary (still)debugging interface. You probably want to check out the GHCi debugger (in GHC head), and GuiHat [http://www-users.cs.york.ac.uk/~ndm/hat/] Thanks Neil

1 0

IDE support
by Philipp Volgger 29 Apr '07

29 Apr '07

What IDE support is available for Haskell (Visuall Haskell, EclipseFP), anything else?

12 18

run-time type testing in haskell?
by Eric 28 Apr '07

28 Apr '07

In imperative languages one can test the type of a variable and downcast if necessary. Here's an example in Pseudojava: T v := ... ; if (v instanceof T') T' v' := (T')v Is it possible to do something like this in Haskell? Eric.

6 6

Parsec beginners problem
by Jim Burton 28 Apr '07

28 Apr '07

I have a couple of questions about my first use of Parsec, which is trying to read morse code symbols from a string. I have a map of symbols: import qualified Data.Map as M morsemap = M.fromList [('A', ".-") ... , ('Z', "--..")] a string to parse, like test = "...---..-....-" and a Parser to read a single morse letter: morse1 :: GenParser Char st String morseletter = try $ M.fold ((<|>) . string) (string "") morsemap which I am hoping would be equivalent to try (string ".-") <|> (string "-.") ...etc <|> string "" but I don't know what the base of the fold should be (string "" is wrong I suppose) - what is the unit of <|>? Is there a readymade combinator for this? It fails anyway: *Main> run morse1 test parse error at (line 1, column 1): unexpected "." expecting ".-" I suppose this is because the strings I'm looking for overlap but I thought the use of try..<|> would avoid this error...? Thanks, -- View this message in context: http://www.nabble.com/Parsec-beginners-problem-tf3657821.html#a10219707 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

5 7

I need help on AVL trees
by iliali16 28 Apr '07

28 Apr '07

Can someone advise me how can I build an AVL tree becouse I have difficulties with the rotations. Since if I add a node I want to be abel to check whether the tree is balanced or not if balanced ok but if not I need to do one of the 4 rotations which is a problem for me and I want to be able to give the nodes from the keyboard. What I mean is that it is possible to build the tree from scratch. Thanks to all! -- View this message in context: http://www.nabble.com/I-need-help-on-AVL-trees-tf3657386.html#a10218190 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 2

tiff reader or libtiff bindings
by Andreas Voellmy 28 Apr '07

28 Apr '07

Hi, Does anyone know of a haskell library to read (and write) tiff files? Or has someone written a binding to libtiff? Thanks, Andreas

2 1

New HaskODell user groups
by dons＠cse.unsw.edu.au 28 Apr '07

28 Apr '07

I've created a new wiki page documenting all the new user groups for Haskell that are springing up! http://haskell.org/haskellwiki/User_groups If you're starting a new group, please add it here, and publicise. -- Don P.S. Some obvious user group candidates, in my opinion, would be a Portland group, a Bay Area group and something at Chalmers... ;-)

3 2

Question: template-haskell and profiling
by ET 27 Apr '07

27 Apr '07

Hi, folks Trying to profile the modules, those contain a template-haskell splices, I have ran into problem - GHC6.4 (win2K) returns an error message and then stops. Without the "-prof" option all works fine. Is there a way to bypass this inconsistency? Example below illustrates the problem: ============================ {-# OPTIONS_GHC -fth #-} module Main where import MainTH main :: IO () main = putStrLn . show . fact $ 100 fact :: Integer -> Integer fact n = $(thFact "n") ============================ module MainTH where import Language.Haskell.TH thFact :: String -> ExpQ thFact s = appE (dyn "product") (arithSeqE (fromToR (litE . integerL $ 1) (dyn s))) preview :: IO () preview = runQ (thFact "x") >>= putStrLn . pprint ============================ >ghc --make -prof Main.hs Chasing modules from: Main.hs Compiling MainTH ( ./MainTH.hs, ./MainTH.o ) Compiling Main ( Main.hs, Main.o ) Loading package base-1.0 ... linking ... done. Loading package haskell98-1.0 ... linking ... done. Loading package template-haskell-1.0 ... linking ... done. ghc: ./MainTH.o: unknown symbol `_era' With function "MainTH.preview" excluded from export list, final phrase were ghc: ./MainTH.o: unknown symbol `_entering_PAP'

3 2

Multi Line String literals
by Bas van Dijk 27 Apr '07

27 Apr '07

Hello, Just for fun I'm trying to define multi line string literals. I have the following code and I'm wondering if it can be improved (understandability, elegance, performance): http://hpaste.org/1582 (look at the second annotation) regards, Bas van Dijk

6 8

Haskell Weekly News: April 27, 2007
by dons＠cse.unsw.edu.au 27 Apr '07

27 Apr '07

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20070427 Issue 61 - April 27, 2007 --------------------------------------------------------------------------- Welcome to issue 61 of HWN, a weekly newsletter covering developments in the [1]Haskell community. The last week was a very exciting week for the Haskell community, with a new GHC release, the first release of Xmonad, a window manager written in Haskell, and DisTract, a new distributed bug tracker, written in Haskell. A number of new Haskell jobs were announced, and several new user groups were formed! 1. http://haskell.org/ Announcements GHC 6.6.1. Ian Lynagh [2]announced a new patchlevel release of GHC. This release contains a significant number of bugfixes relative to 6.6, so we recommend upgrading. Release notes are [3]here. GHC is a state-of-the-art programming suite for Haskell. Included is an optimising compiler generating good code for a variety of platforms, together with an interactive system for convenient, quick development. The distribution includes space and time profiling facilities, a large collection of libraries, and support for various language extensions, including concurrency, exceptions, and foreign language interfaces. 2. http://article.gmane.org/gmane.comp.lang.haskell.glasgow.user/12075 3. http://haskell.org/ghc/docs/6.6.1/html/users_guide/release-6-6-1.html Xmonad 0.1. Spencer Janssen [4]announced the inaugural release of [5]Xmonad. Xmonad is a minimalist tiling window manager for X, written in Haskell. Windows are managed using automatic layout algorithms, which can be dynamically reconfigured. At any time windows are arranged so as to maximise the use of screen real estate. All features of the window manager are accessible purely from the keyboard: a mouse is entirely optional. Xmonad is configured in Haskell, and custom layout algorithms may be implemented by the user in config files. 4. http://article.gmane.org/gmane.comp.lang.haskell.general/15131 5. http://xmonad.org/ DisTract: Distributed Bug Tracker implemented in Haskell. Matthew Sackman [6]announced DisTract, a [7]Distributed Bug Tracker. We're all now familiar with working with distributed software control systems, such as Monotone, Git, Darcs, Mercurial and others, but bug trackers still seem to be fully stuck in the centralised model: Bugzilla and Trac both have single centralised servers. This is clearly wrong, as if you're able to work on the Train, off the network and still perform local commits of code then surely you should also be able to locally close bugs too. DisTract allows you to manage bugs in a distributed manner through your web-browser. The distribution is achieved by making use of a distributed software control system, Monotone. Thus Monotone is used to move files across the network, perform merging operations and track the development of every bug. Finally, the glue in the middle that generates the HTML summaries and modifies the bugs is written in Haskell. 6. http://article.gmane.org/gmane.comp.lang.haskell.cafe/21857 7. http://www.distract.wellquite.org/ IOSpec 0.1. Wouter Swierstra [8]announced the first release of the [9]Test.IOSpec library, that provides a pure specification of some functions in the IO monad. This may be of interest to anyone who wants to debug, reason about, analyse, or test impure code. Essentially, by importing libraries from IOSpec you can the same code you would normally write in the IO monad. Once you're satisfied that your functions are reasonably well-behaved, you can remove the Test.IOSpec import and replace it with the 'real' functions instead. 8. http://article.gmane.org/gmane.comp.lang.haskell.general/15134 9. http://www.cs.nott.ac.uk/~wss/repos/IOSpec wl-pprint-1.0: Wadler/Leijen pretty printer. Stefan O'Rear [10]announced wl-pprint-1.0, the classic Wadler / Leijen pretty printing combinators, now in 100% easier to use [11]Cabalised form! PPrint is an implementation of the pretty printing combinators described by Philip Wadler (1997). In their bare essence, the combinators of Wadler are not expressive enough to describe some commonly occurring layouts. The PPrint library adds new primitives to describe these layouts and works well in practice. 10. http://thread.gmane.org/gmane.comp.lang.haskell.general/15112 11. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/wl-pprint-1.0 London Haskell User Group. Neil Bartlett [12]announced the first meeting of the [13]London Haskell User Group on Wednesday 23rd May from 6:30PM. The meeting will be held at City University's main campus in central London, and Simon Peyton Jones will be coming to give a talk. 12. http://article.gmane.org/gmane.comp.lang.haskell.cafe/21955 13. http://www.londonhug.net/2007/04/26/announcement-first-meeting-of-the-londo… New York Functional Programmers Network. Howard Mansell [14]announced a New York area-based network for Haskell (and functional) programmers. The idea is to have a regular meeting through which functional programmers can meet to discuss experiences, get and give information, find jobs. 14. http://article.gmane.org/gmane.comp.lang.haskell.cafe/21856 Data.Proposition 0.1. Neil Mitchell [15]announced the release of [16]Data.Proposition, a library that handles propositions, logical formulae consisting of literals without quantification. It automatically simplifies a proposition as it is constructed using simple rules provided by the programmer. Implementations of propositions in terms of an abstract syntax tree and as a Binary Decision Diagram (BDD) are provided. A standard interface is provided for all propositions. 15. http://article.gmane.org/gmane.comp.lang.haskell.general/15117 16. http://www-users.cs.york.ac.uk/~ndm/proposition/ Book reviews for the Journal of Functional Programming. Simon Thompson [17]sought interested contributors for book reivews for the Journal of Functional Programming. There is a list of books [18]currently available for review. 17. http://article.gmane.org/gmane.comp.lang.haskell.general/15136 18. http://www.cs.kent.ac.uk/people/staff/sjt/JFP/available.html Reminder: HCAR May 2007. Andres Loeh [19]reminded us that the deadline for the May 2007 edition of the Haskell Communities and Activities Report is only a few days away -- but this is still enough time to make sure that the report contains a section on your project, on the interesting stuff that you've been doing; using or affecting Haskell in some way. 19. http://article.gmane.org/gmane.comp.lang.haskell.general/15161 Template 0.1: Simple string substitution. Johan Tibell [20]announced a simple [21]string substitution library that supports substitution ala Perl or Python. 20. http://article.gmane.org/gmane.comp.lang.haskell.general/15135 21. http://darcs.johantibell.com/template hpaste for emacs. David House [22]announced hpaste.el, an Emacs Lisp library that integrates [23]hpaste, the Haskell pastebin, into Emacs. It provides two functions, hpaste-paste-region and hpaste-paste-buffer, which send the region or buffer to the hpaste server as required. 22. http://thread.gmane.org/gmane.comp.lang.haskell.glasgow.user/12046 23. http://hpaste.org/ Haskell' This section covers the [24]Haskell' standardisation process. * [25]General pattern bindings * [26]Relax the restriction on Bounded derivation * [27]data syntax * [28]Mathematical preludes * [29]Literate Haskell specification 24. http://hackage.haskell.org/trac/haskell-prime 25. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2178 26. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2183 27. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2184 28. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2189 29. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2190 Libraries This week's proposals and extensions to the [30]standard libraries. * [31]Add a MonadState instance for the Parsec monad * [32]Use 'Wide' API if System has it 30. http://haskell.org/haskellwiki/Library_submissions 31. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6778 32. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6848 Hackage This week's new libraries in [33]the Hackage library database. * [34]X11-extras-0.1 * [35]hinstaller-2007.4.24 * [36]IOSpec-0.1.1 * [37]gd-3000.0.1 * [38]xmonad-0.1 * [39]YamlReference-0.3 * [40]parsedate-2006.11.10 * [41]chunks-2007.4.18 * [42]wl-pprint-1.0 * [43]Emping-0.1 * [44]hsns-0.5.1 * [45]htar-0.1 * [46]cabal-upload-0.3 * [47]unix-compat-0.1 * [48]tar-0.1 33. http://hackage.haskell.org/ 34. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/X11-extras-0.1 35. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hinstaller-2007.… 36. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/IOSpec-0.1.1 37. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/gd-3000.0.1 38. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmonad-0.1 39. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/YamlReference-0.3 40. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/parsedate-2006.1… 41. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/chunks-2007.4.18 42. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/wl-pprint-1.0 43. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Emping-0.1 44. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hsns-0.5.1 45. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/htar-0.1 46. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/cabal-upload-0.3 47. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/unix-compat-0.1 48. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/tar-0.1 Discussion GHC Release Plans. Simon Marlow [49]initiated a discussion on possibe release timelines for upcoming GHC versions. 49. http://thread.gmane.org/gmane.comp.lang.haskell.glasgow.user/12014 More inlining. Duncan Coutts [50]asked about more fine grained control over inlining in GHC, to ease term rewriting with RULES 50. http://thread.gmane.org/gmane.comp.lang.haskell.glasgow.user/12046 Haskell version of Norvig's Python Spelling Corrector. Pete Kazmier [51]spawned a long thread covering various implementations of spelling correctors in Haskell 51. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/21780 Jobs Quantitative Functional Programmer. Credit Suisse. [52]The Global Modelling and Analytics Group (GMAG) is responsible for producing state-of-the-art pricing, trading and hedging models for Credit Suisse. These models are used across a range of businesses in the Fixed Income and Equity Divisions. The groups mandate covers all major asset classes including Credit Derivatives, Commodities, Emerging Markets, Equity Derivatives and Convertibles, Exotics, Foreign Exchange, Fund Linked Products, Interest Rate Products and Mortgage Derivatives. GMAG operates globally with 85 members located in New York, London, Hong Kong and Tokyo. We are currently building a Domain Specific Language (embedded in Haskell) that will be used within GMAG. We require intelligent, motivated people to develop and extend this language. These individuals will also work with modellers to aid them in effectively applying these new tools. 52. http://tinyurl.com/2lqoq9 Haskell programmer positions. HAppS. HAppS LLC has [53]part-time and full-time positions open for Haskell programmers to: improve the open source Haskell codebase at HAppS.org; implement infrastructure to make it work well in Amazon S3/EC2 environments; make http://pass.net reliable enough to be used by live apps; build the mass market apps we want to run on top of the HAppS/Pass.net platform. We are looking for people who: have substantial experience programming Haskell; have experience building Internet apps (not necessarily in Haskell but would be good), and live in any of these places: the Internet, New York, San Francisco Los Angeles. 53. http://article.gmane.org/gmane.comp.lang.haskell.cafe/21951 Vacancy for a PhD student. Johan Jeuring [54]announced a vacancy for a PhD student in the Strategy Feedback project. Knowledge of Haskell is a big plus; implementation of most of the tools will be done in Haskell. Length: 1+3 years, Open University the Netherlands, Location: Heerlen. 54. http://article.gmane.org/gmane.comp.lang.haskell.cafe/21740 Blog noise [55]Haskell news from the blogosphere. * [56]Overloading Haskell numbers, part 1, symbolic expressions * [57]Overloading Haskell numbers, part 2, Forward Automatic Differentiation * [58]Overloading Haskell numbers, part 3, Fixed Precision * [59]More Haskell parallelism * [60]Haskell status: impressed * [61]On haskell: writing a packet sniffer * [62]Must-see Haskell talks at OSCON 07 * [63]Zen and the Art of Functional Programming * [64]Playing with sections in Haskell * [65]More playing with sections (and flip) * [66]Thinking in objects * [67]Robot localization using a particle system monad * [68]21 open problems in typed lambda calculus * [69]Arrows and security in Haskell * [70]Haskell GUI Programing * [71]Splitting a string in Haskell * [72]Introduction to Haskell: I like it a lot * [73]Haskell (ish) code, Java gui * [74]Haskell wikibook blurb * [75]Functional and Object-Oriented Programming * [76]Xmonad: a lightweight window manager * [77]Xmonad: a tiling window manager written in Haskell * [78]Xmonad: Haskell window management has arrived * [79]Xmonad: a minimal window manager in Haskell * [80]Xmonad: in the footsteps of wmii * [81]Xmonad: a new window manager * [82]Haskell code * [83]IO in Haskell * [84]Haskell records considered grungy 55. http://planet.haskell.org/ 56. http://augustss.blogspot.com/2007/04/overloading-haskell-numbers-part-1.html 57. http://augustss.blogspot.com/2007/04/overloading-haskell-numbers-part-2.html 58. http://augustss.blogspot.com/2007/04/overloading-haskell-numbers-part-3.html 59. http://mikeburrell.wordpress.com/2007/04/16/more-haskell-parallelism/ 60. http://austin.youareinferior.net/?q=node/21 61. http://austin.youareinferior.net/?q=node/24 62. http://www.serpentine.com/blog/2007/04/16/must-see-haskell-talks-at-oscon-0… 63. http://azaidi.blogspot.com/2007/04/zen-and-art-of-functional-programming.ht… 64. http://gimbo.org.uk/blog/2007/04/13/playing-with-sections-in-haskell/ 65. http://gimbo.org.uk/blog/2007/04/19/more-playing-with-sections-and-flip-in-… 66. http://braindump.dk/tech/2007/04/16/thinking-in-objects/ 67. http://www.randomhacks.net/articles/2007/04/19/robot-localization-particle-… 68. http://tlca.di.unito.it/opltlca/ 69. http://abstractabsurd.blogspot.com/2007/04/arrows-security.html 70. http://araujoluis.blogspot.com/2007/04/haskell-gui-programing.html 71. http://gimbo.org.uk/blog/2007/04/20/splitting-a-string-in-haskell/ 72. http://www.noulakaz.net/weblog/2007/04/20/i-like-haskell-a-lot/ 73. http://jpmoresmau.blogspot.com/2007/04/haskell-code-java-ui.html 74. http://koweycode.blogspot.com/2007/04/haskell-wikibook-blurb.html 75. http://weblog.raganwald.com/2007/04/we-dont-need-no-stinkin-scientific.html 76. http://lennartkolmodin.blogspot.com/2007/04/xmonad.html 77. http://www.osnews.com/story.php/17744/Xmonad-a-Tiling-Window-Manager-Writte… 78. http://existentialtype.net/?p=113 79. http://gimbo.org.uk/blog/2007/04/22/xmonad-a-minimal-window-manager-in-hask… 80. http://ephemient.livejournal.com/38438.html 81. http://jpatrao-online.blogspot.com/2007/04/xmonad-new-windowmanager.html 82. http://www.wardtek.ca/2007/04/haskell-code-number-one/ 83. http://www.friendofthepigeon.co.uk/wordpress/?p=54 84. http://bloggablea.wordpress.com/2007/04/24/haskell-records-considered-grung… Quotes of the Week * apfelmus: Programming in Haskell is like dual-wielding two light sabers whereas programming in imperative languages is like being equipped with a blunt kitchen knife. * mwc: C++ is multiparadigm in the same way a dog with 4 table legs nailed onto it is an octopus * ptolomy: Sometimes Haskell feels like a personal trainer for proper program construction. You half-ass something, and the compiler doesn't let you get away with it and won't let you move on until you do it right. * dons: I wish you success and may your lambdas always beta reduce * quicksilver: May your years be long and your type inference algorithms sound. * inverselimit: So I tried as my first project in Haskell to write something that decomposes modules of polynomials using Schur-Weyl duality. This turned out to be a little tricky without being comfortable with the syntax * jcreigh: Could not find instance Ord for type ProgrammingLanguage Code Watch Apr 19 07:23:58 PDT 2007. Simon Marlow. [85]More debugger improvements. :list shows the code around the current breakpoint. Also it highlights the current expression in bold (the bold/unbold codes are hardwired to the ANSI codes right now, I'll provide a way to change them later). :set stop cmd' causes cmd to be run each time we stop at a breakpoint. In particular, :set stop :list is particularly useful. 85. http://article.gmane.org/gmane.comp.lang.haskell.cvs.ghc/20269 Wed Apr 25 03:18:32 PDT 2007. simonpj. [86]Add -fwarn-monomorphism-restriction (on by default) to warn when the MR is used. Users often trip up on the Dreaded Monomorphism Restriction. This warning flag tells you when the MR springs into action. Currently it's on by default, but we could change that. 86. http://article.gmane.org/gmane.comp.lang.haskell.cvs.ghc/20359 Thu Apr 26 02:37:19 PDT 2007. Pepe Iborra. New section on [87]debugging lambdas in the ghci user guide 87. http://article.gmane.org/gmane.comp.lang.haskell.cvs.ghc/20404 About the Haskell Weekly News Each week, new editions are posted to [88]the Haskell mailing list as well as to [89]the Haskell Sequence and [90]Planet Haskell. [91]RSS is also available, and headlines appear on [92]haskell.org. Headlines are available as [93]PDF. To help create new editions of this newsletter, please see the [94]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get [95]http://www.cse.unsw.edu.au/~dons/code/hwn 88. http://www.haskell.org/mailman/listinfo/haskell 89. http://sequence.complete.org/ 90. http://planet.haskell.org/ 91. http://sequence.complete.org/node/feed 92. http://haskell.org/ 93. http://www.cse.unsw.edu.au/~dons/code/hwn/archives/20070427.pdf 94. http://haskell.org/haskellwiki/HWN 95. http://www.cse.unsw.edu.au/~dons/code/hwn

1 0

Obscure instances for Obscure types
by Neil Mitchell 27 Apr '07

27 Apr '07

Hi I currently maintain two libraries, TagSoup which defines the Tag data type, and BinaryDefer, which defines the BinaryDefer class. If I wanted to include an instance for BinaryDefer Tag, where would I put it? Putting it in either library introduces an artificial dependency on the other. Putting it in a separate libary makes the library about 4 lines long and is just annoying. Putting it in the individual application(s) is exactly what libraries were designed to avoid. Is there a solution? Thanks Neil

4 4

ANN: London Haskell User Group
by Neil Bartlett 27 Apr '07

27 Apr '07

I am delighted to announce the first meeting of the London Haskell User Group on Wednesday 23rd May from 6:30PM. The meeting will be held at City University's main campus in central London, and Simon Peyton Jones will be coming to give a talk. Please see the announcement on the web page for more details and to register: http://www.londonhug.net/2007/04/26/announcement-first-meeting-of-the- london-haskell-user-group/ Many thanks to Simon, and to Ross Paterson at City University for organising the room. Regards, Neil

1 0

Stack overflow with my Trie implementation
by Pete Kazmier 27 Apr '07

27 Apr '07

I've modified my Norvig spelling corrector to use a trie instead of Data.Map in the hopes of improving performance. Plus, this is fun and a great learning exercise for me. Unfortunately, when I load my trie with a large amount of data, I get a stack overflow. It's unclear to me why this is happening. I specifically use foldl' to avoid this situation when building my trie. Could someone shed some light on the situation for me? Here is the code: > module Main where > > import Data.List (foldl') > import Data.Maybe (maybe, fromMaybe) > import Prelude hiding (lookup) > import qualified Data.Map as M > > data Trie a = T (Maybe a) (M.Map Char (Trie a)) deriving (Show) > > main = do > -- big.txt is a large file of words: http://www.norvig.com/big.txt > c <- readFile "big.txt" > let freqTrie = foldl' incWordCount empty (words c) > print $ lookup "evening" freqTrie > where > incWordCount m w = insertWith (+) w 1 m > > empty :: Trie a > empty = T Nothing M.empty > > lookup :: String -> Trie a -> Maybe a > lookup ([]) (T Nothing m) = Nothing > lookup ([]) (T (Just v) m) = return v > lookup (k:ks) (T _ m) = case M.lookup k m of > Nothing -> Nothing > Just trie -> lookup ks trie > > findWithDefault :: a -> String -> Trie a -> a > findWithDefault v k t = fromMaybe v (lookup k t) > > member :: String -> Trie a -> Bool > member k t = maybe False (const True) (lookup k t) > > insertWith :: (a -> a -> a) -> String -> a -> Trie a -> Trie a > insertWith fn ([]) v (T Nothing m) = T (Just v) m > insertWith fn ([]) v (T (Just v') m) = T (Just $ fn v v') m > insertWith fn (k:ks) v (T mv m) = T mv (M.insertWith const k newtrie m) > where > oldtrie = M.findWithDefault empty k m > newtrie = insertWith fn ks v oldtrie > > {-- I also tried to use this line instead of the one above to see > if this had any impact. Unfortunately, I obtained the same > results. > > insertWith fn ([]) v (T (Just v') m) = let x = fn v v' in seq x T (Just x) m > --}

2 2

Haskell Job Opportunity
by S. Alexander Jacobson 27 Apr '07

27 Apr '07

HAppS LLC has part-time and full-time positions open for haskell programmers to: * improve the open source haskell codebase at HAppS.org * implement infrastructure to make it work well in Amazon S3/EC2 environments * make http://pass.net reliable enough to be used by live apps * build the mass market apps we want to run on top of the HAppS/Pass.net platform We are looking for people who: * have substantial experience programming Haskell * have experience building Internet apps (not necessarily in Haskell but would be good), and * live in any of these places: * the Internet (with comfort working entirely over email,skype,tightVNC etc.) * New York * San Francisco * Los Angeles If you qualify and are interested, please send an email with your cv/resume to me or to <opportunity> AT <happs.org>. -Alex-

1 0

Re: [Haskell] Newbie: what are the advantages of Haskell?
by Joel Reymont 27 Apr '07

27 Apr '07

The biggest advantage of Haskell to me is that it helps me write better programs in other languages. For one reason or another Haskell never turns out to be my final implementation language my my programs gain in the process. Joel -- http://wagerlabs.com/

1 0

On reflection
by Greg Meredith 26 Apr '07

26 Apr '07

Oleg, Simon, Thanks for your help. If i understand it correctly, the code below gives a reasonably clean first cut at a demonstration of process calculi as polymorphically parametric in the type of name, allowing for an instantiation of the type in which the quoted processes play the role of name. This is much, much cleaner and easier to read than the OCaml version. Best wishes, --greg {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances #-} module Core( Nominal ,Name ,Locality ,Location ,CoreProcessSyntax ,CoreAgentSyntax ,MinimalProcessSyntax ,MinimalAgentSyntax ,ReflectiveProcessSyntax -- ,make_process ) where -- What's in a name? class Nominal n where nominate :: i -> n i -- newtype Name i = Nominate i deriving (Eq, Show) newtype Name i = Name i deriving (Eq, Show) instance Nominal Name where nominate i = Name i -- Where are we? class Locality a where locate :: (Eq s, Nominal n) => s -> (n i) -> a s (n i) name :: (Eq s, Nominal n) => a s (n i) -> (n i) -- data Location s n = Locate s n deriving (Eq, Show) data Location s n = Location s n deriving (Eq, Show) instance Locality Location where locate s n = Location s n name (Location s n) = n -- Constraints class CoreProcessSyntax p a x | p -> a x where zero :: p sequence :: a -> x -> p compose :: [p] -> p class CoreAgentSyntax x p n | x -> p n where bind :: [n] -> p -> x offer :: [n] -> p -> x -- Freedom (as in freely generated) data MinimalProcessSyntax l x = Null | Sequence l x | Composition [MinimalProcessSyntax l x] data MinimalAgentSyntax n p = Thunk (() -> p) | Abstraction ([n] -> p) | Concretion [n] p -- Responsibility : constraining freedom to enjoy order instance CoreProcessSyntax (MinimalProcessSyntax l x) l x where zero = Null sequence l a = Sequence l a compose [] = zero compose ps = Composition ps instance CoreAgentSyntax (MinimalAgentSyntax n p) p n where bind [] proc = Thunk (\() -> proc) -- -- TODO : lgm : need to substitute m for name in proc bind (name:names) proc = Abstraction (\m -> comp $ bind names proc) where comp (Thunk fp) = fp () -- comp (Abstraction abs) = abs name offer names proc = Concretion names proc data ReflectiveProcessSyntax = Reflect (MinimalProcessSyntax (Location [(Name ReflectiveProcessSyntax)] (Name ReflectiveProcessSyntax)) (MinimalAgentSyntax (Name ReflectiveProcessSyntax) ReflectiveProcessSyntax)) -- instance (CoreProcessSyntax p a x) => -- CoreProcessSyntax -- (MinimalProcessSyntax -- (Location -- [(Name (MinimalProcessSyntax a x))] -- (Name (MinimalProcessSyntax a x))) -- (MinimalAgentSyntax -- (Name (MinimalProcessSyntax a x)) -- (MinimalProcessSyntax a x))) -- (Location -- [(Name (MinimalProcessSyntax a x))] -- (Name (MinimalProcessSyntax a x))) -- (MinimalAgentSyntax -- (Name (MinimalProcessSyntax a x)) -- (MinimalProcessSyntax a x)) -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

2 1

Talking to the serial (RS232) port from Haskell
by Dan Piponi 26 Apr '07

26 Apr '07

What's the easiest way, from Haskell, to open a serial port (under Windows, say) with the correct baud rate and parity, and send data through it? Is there a serial library for Haskell? -- Dan

2 1

Programming Languages and Mechanised Mathematics -- deadline extension
by Jacques Carette 25 Apr '07

25 Apr '07

[Extended deadline: submissions now due May 2nd, 2007] Programming Languages for Mechanized Mathematics Workshop As part of Calculemus 2007 <http://www.risc.uni-linz.ac.at/about/conferences/Calculemus2007/> Hagenbergs, Austria June 29-30, 2007. The intent of this workshop is to examine more closely the intersection between programming languages and mechanized mathematics systems (MMS). By MMS, we understand computer algebra systems (CAS), [automated] theorem provers (TP/ATP), all heading towards the development of fully unified systems (the MMS), sometimes also called universal mathematical assistant systems (MAS) (see Calculemus 2007 <http://www.risc.uni-linz.ac.at/about/conferences/Calculemus2007/>). There are various ways in which these two subjects of /programming languages/ and /systems for mathematics/ meet: * Many systems for mathematics contain a dedicated programming language. For instance, most computer algebra systems contain a dedicated language (and are frequently built in that same language); some proof assistants (like the Ltac language for Coq) also have an embedded programming language. Note that in many instances this language captures only algorithmic content, and /declarative/ or /representational/ issues are avoided. * The /mathematical languages/ of many systems for mathematics are very close to a functional programming language. For instance the language of ACL2 is just Lisp, and the language of Coq is very close to Haskell. But even the mathematical language of the HOL system can be used as a functional programming language that is very close to ML and Haskell. On the other hand, these languages also contain very rich specification capabilities, which are rarely available in most computation-oriented programming languages. And even then, many specification languages (B, Z, Maude, OBJ3, CASL, etc) can still teach MMSes a trick or two regarding representational power. * Conversely, functional programming languages have been getting "more mathematical" all the time. For instance, they seem to have discovered the value of dependent types rather recently. But they are still not quite ready to 'host' mathematics (the non-success of docon <http://www.haskell.org/docon/> being typical). There are some promising languages on the horizon (Epigram <http://www.e-pig.org/>, Omega <http://web.cecs.pdx.edu/%7Esheard/Omega/index.html>) as well as some hybrid systems (Agda <http://agda.sourceforge.net/>, Focal <http://focal.inria.fr/site/index.php>), although it is unclear if they are truly capable of expressing the full range of ideas present in mathematics. * Systems for mathematics are used to prove programs correct. (One method is to generate "correctness conditions" from a program that has been annotated in the style of Hoare logic and then prove those conditions in a proof assistant.) An interesting question is what improvements are needed for this both on the side of the mathematical systems and on the side of the programming languages. We are interested in all these issues. We hope that a certain synergy will develop between those issues by having them explored in parallel. These issues have a very colourful history. Many programming language innovations first appeared in either CASes or Proof Assistants, before migrating towards more mainstream languages. One can cite (in no particular order) type inference, dependent types, generics, term-rewriting, first-class types, first-class expressions, first-class modules, code extraction, and so on. However, a number of these innovations were never aggressively pursued by system builders, letting them instead be developped (slowly) by programming language researchers. Some, like type inference and generics have flourished. Others, like first-class types and first-class expressions, are not seemingly being researched by anyone. We want to critically examine what has worked, and what has not. Why are all the current ``popular''[1] computer algebra systems untyped? Why are the (strongly typed) proof assistants so much harder to use than a typical CAS? But also look at question like what forms of polymorphism exists in mathematics? What forms of dependent types exist in mathematics? How can MMS regain the upper hand on issues of 'genericity'? What are the biggest barriers to using a more mainstream language as a host language for a CAS or an ATP? This workshop will accept two kinds of submissions: full research papers as well as position papers. Research papers should be nore more than 15 pages in length, and positions papers no more than 3 pages. Submission will be through _EasyChair_. An informal version of the proceedings will be available at the workshop, with a more formal version to appear later. We are looking into having the best papers completed into full papers and published as a special issue of a Journal (details to follow). Important Dates May 02, 2007: Submission Deadline (Extended!) May 30, 2007: Notification June 29-30, 2007: Workshop Program Committee Lennart Augustsson [Credit Suisse] Wieb Bosma [Radboud University Nijmegen, Netherlands] Jacques Carette (co-Chair) [McMaster University, Canada] David Delahaye [CNAM, France] Jean-Christophe Filliâtre [CNRS and Université de Paris-Sud, France] John Harrison [Intel Corporation, USA] Josef Urban [Charles University, Czech Republic] Markus (Makarius) Wenzel [Technische Universität München, Germany] Freek Wiedijk (co-Chair) [Radboud University Nijmegen, Netherlands] Wolfgang Windsteiger [University of Linz, Austria] Location and Registration Location and registration information can be found on the Calculemus <http://www.risc.uni-linz.ac.at/about/conferences/Calculemus2007/> web site. ----------------------------------------------------------------------------- [1] by popular we mean > 1 million users.

1 0

Program optimisation
by Andrew Coppin 25 Apr '07

25 Apr '07

I have *no idea* if this is an appropriate place to put this, but here goes... I have a (presumably) common problem. I have a nice Haskell program. It's compute-bounded, and I'd like to make it go faster. To that end, I've been trying to optimise it. Without going into great detail, the program basically revolves around processing a list and dumping the results into a file. Notable things about this structure: it's *big*, and I only need to *map* over it. Anyway, here's what I did... I wrote a simplified, cut down version of the program so I would have a fixed test case. I compiled it with GHC 6.6 and ran it. It takes 40 seconds to complete. Next, I read the GHC manual. Apparently there's a command-line switch "-O2" which makes GHC try harder to optimise the program. (I had stupidly assumed it always tries to make good code...) The result? The program now does the same job in 30 seconds. That's quite a big speedup just for typing 3 characters! (Gee... I wonder what it does differently? I did notice that the compilation time went from 5 seconds up to 20 seconds. And the *.exe got smaller.) Next I played with profiling. If I'm reading this correctly, the "-s" profile is telling me that my program spends 72% CPU time doing GC. o_O Er... that's really suboptimal. Also - and this is really weird - the "-p" profile tells me that 82% of the program's time is spent in the quant8 function. The source code for this function is precisely quant8 :: Double -> Word8 quant8 x = floor $ x * 0xFF Why that should take 82% CPU when the program is also doing heavy-metal complex number arithmetic and trig functions I have no idea! (Since I took those measurements, I have come up with a theory. When I ask for all these computations to be done... Haskell doesn't actually *do* them. It just stores them up until "needed". It just occurred to me that quant8 is the *last* thing I ask it to do before the code hits a strict ByteString... So is the profiler just misappropriating all the work to quant8 when it's really elsewhere?) OK, so to recap: currently my program takes 30 seconds to run. Next, I changed the 2D lists (i.e., [[x]]) into 1D lists (that is, [x]). The new runtime? 30 seconds. Right, that seems to be no-op. Next I replaced lists with immutable boxed arrays. New runtime: 33 seconds. Ooops. Now, I would have thought an array would make the GC's life *much* easier by replacing tens of thousands of cons cells with one nice big array. But, apparently, no. The profiler output says GC is almost identical. Hmm... weird! Next, I switched to IO-mutable boxed arrays. (With in-place updates.) New runtime: 35 seconds. Da hell...? The more I optimise this program, the slower it goes! :'( Finally, in a fit of desperation, I changed it to *unboxed* arrays. For some reason, you can't have an unboxed array of complex numbers. So I had to make *two* unboxed arrays of doubles, and manually split/join myself. Similar problems happened elsewhere too. Suffice it to say, my program is now vomit-inducingly ugly. It doesn't even *function* correctly any more! (There's a byte alignment issue somewhere... I can't track it down.) New runtime: 15 seconds. I say again: 15 seconds. Changing to an unboxed array has *doubled* the speed. Not only that, the GC report now shows GC as using 7% CPU time, and peak RAM usage has been reduced from 25 MB to 4 MB. The memory graph is now utterly flat, whereas even with IO-mutable arrays with in-place update, it was still fluctuating all over the place. I will mention that the ByteString module was the only thing I would find in all of Haskell for doing binary I/O. The final (fast) program uses an IOUArray Int Word8 to do the binary I/O instead. (What's the difference BTW? Is there one? Other than the name anyway.) Perhaps part of the speed was in avoiding an array type conversion? I don't know. Certainly this is the messiest part, and the part where I suspect my bug is hiding. Finally, in the fast version, quant8 uses way less CPU (more like 50%), and the complex number math uses much more. Really goes look like the profiler being counterintuitive to me... Personally, I find it quite worrying that I had to manually mutilate my program to unbox everything when the compiler is supposed to be able to do such things automatically. Does GHC "know" about the array types? Or are they just a bunch of FFI calls that some 3rd party wrote? When I talk to other people about Haskell, they all say "immutable sucks; that must be SO slow!" and I tell them "yeah, but the compiler can strip almost all of it out automatically". Well, my experience with this program suggests very differently. I do wonder if the program went faster just because unboxed arrays are strict. I couldn't think of any way to make a boxed array be strict. (I tried for ages!) Next task: Attempt to make the program use both cores on my dual-core monster machine for even more speed... A short program synopsys: module Main where init_frame :: [[Complex Double]] next_frame :: [[Complex Double]] -> [[Complex Double]] process :: [[Complex Double]] -> [[Colour]] save_file :: FilePath -> [[Colour]] -> IO () main = do work 0 init_frame work n xss = do save_file ("Frame" ++ show n) (process xss) if n < 500 then work (n+1) (next_frame xss) else return ()

3 2

Re: release plans
by Chad Scherrer 25 Apr '07

25 Apr '07

> What do you think of this plan? Are there features/bug-fixes that you really want to see in 6.8? I'm most anxious for parallel GC - do you think it will be another release or two before this is a reality? Thanks, Chad

3 2

HXT namespace problem
by Martin Huschenbett 25 Apr '07

25 Apr '07

Hi all, I'm currently trying to generate XML documents with HXT. Everything went well but I can't figure out how to generate the "xmlns:..." attributes for the namespaces. My code looks like: runX $ constA (request TableListRequest) >>> root [] [writeA] >>> writeDocument [(a_indent,v_1)] "-" where writeA generates the actual content. This code generates something like: <?xml version="1.0" encoding="UTF-8"?> <soapenv:Envelope> <soapenv:Body> <request:tablelist/> </soapenv:Body> </soapenv:Envelope> But I want it with XML namespaces, i.e.: <?xml version="1.0" encoding="UTF-8"?> <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:request="http://www.officematic.de/domas/request" > <soapenv:Body> <request:tablelist/> </soapenv:Body> </soapenv:Envelope> I tried using "uniqueNamespaces" and "uniqueNamespacesFromDeclAndQNames" but neither worked. Maybe I used them in the wrong part of code. The tree representation my document looks like: ---XTag "/" | +---XTag "{http://schemas.xmlsoap.org/soap/envelope/}soapenv:Envelope" | +---XTag "{http://schemas.xmlsoap.org/soap/envelope/}soapenv:Body" | +---XTag "{http://www.officematic.de/domas/request}request:tablelist" and for me this looks like if there is enough namespace information provided. I would appreciate any help, Martin.

2 2

Why Perl is more learnable than Haskell
by kynn 25 Apr '07

25 Apr '07

Perl is a large, ugly, messy language filled with quirks and eccentricities, while Haskell is an extremely elegant language whose design is guided by a few overriding ideas. (Or so I'm told.) Based on this one would think that it would be much easier to learn Haskell than to learn Perl, but my experience is exactly the opposite. I've been wanting to learn Haskell for years, literally, but it has been a case of Sisyphus and the Rock. Despite my efforts, I never get to the level of expertise that would make Haskell useful to me. (I don't need elegant factorial or Fibonacci functions in my everyday work.) Sooner or later life intervenes: big project due, long trip abroad, etc., and when I finally return to learning Haskell, I have forgotten almost everything I learned and I have to start all over again. (BTW, I've heard similar stories from many wannabe Haskell programmers.) Arguably, this experience means that I have no business learning Haskell, because it's just not relevant to my work. Maybe so, but I still cling to the fanciful notion that if I knew Haskell well enough, I would find plenty of stuff to do with it in my daily work... Anyway, in contrast to my struggle with Haskell, I learned Perl incrementally over the years, by using it in daily little projects, ranging at first from command-line snippets to 100-line self-contained scripts, and moving on to larger, hairier projects. This daily reinforcement of the little bits of Perl I was picking up was crucial to my being able to retain it and move forward. Perhaps Haskell will never lend itself to something like a Perl one-liner, but still I wish that there were books on Haskell that focused on making Haskell useful to the learner as quickly as possible... If such already exist and I've missed it, please let me know. Or I can always wait until I retire; then I'll probably have a sufficiently long stretch of free time in my hands (barring any operations, strokes, heart attacks, hip fractures, etc.). I bet I could start a Haskell Wannabes Club at the nursing home... kj -- View this message in context: http://www.nabble.com/Why-Perl-is-more-learnable-than-Haskell-tf3559193.htm… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

48 77

Re: [Haskell] ANN: IOSpec 0.1
by Wouter Swierstra 25 Apr '07

25 Apr '07

Hi Stefan, > in the Teletype module, it would probably be better to reflect > IOTeletype operations as: > > data Action a = Finish a | Put Char (Action a) | Get (Char -> > Action a) > > That way, there is no need to use (unobservable) laziness. I'm afraid I've lost you. How does this differ from the current definition of IOTeletype? Thanks, Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Re: [Haskell] ANN: IOSpec 0.1
by Wouter Swierstra 25 Apr '07

25 Apr '07

Hi Twan, > Wouter Swierstra wrote: >> Test.IOSpec Version 1.0 > Shouldn't that be 0.1? You're right of course. > You use Dynamic for the data type in IORefs, this has the > unfortunate consequence of needing Typeable constraints. You could > try to use unsafeCoerce instead, > > type Data = () > > unsafeToData :: a -> Data > > unsafeToData = unsafeCoerce > > unsafeFromData :: Data -> a > > unsafeFromData = unsafeCoerce > > I think this should be just as safe as Dynamic, since internally > Dynamic uses unsafeCoerce as well. Just steal the details from there. I'm not entirely happy with the "unsafeFromDynamic" approach I use at the moment. GHC can derive instances of Typeable, so the price you have to pay is not too high. The real problem is that Haskell's type system is not expressive enough to cleanly describe the type of the heap (I know, I could be using HList, but still...). If you're interested, I also have a dependently typed version of the code for IORefs that allows heterogeneous, type-safe, well-scoped pointers. I should probably mention that an ulterior motive for this work is integrating IO in dependently typed languages such as Epigram. It is all, of course, still very much subject to active research. Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Re: [Haskell] ANN: IOSpec 0.1
by Wouter Swierstra 25 Apr '07

25 Apr '07

Hi Isaac, <Moving to Haskell-cafe> > How does or might this relate to the typeclass-based Restricted IO > monad > http://article.gmane.org/gmane.comp.lang.haskell.general/14526 > ? RIO's technique has the advantage that multiple capabilities can be > easily combined in one use of the monad - but this manner of using > typeclasses might interfere with how testable it is? (I think that > should be okay... Also that this is a really neat project - > incremental > progress on taming Haskell IO in practice!) Stefan is absolutely right. The RIO, as far as I remember, restricts which parts of the IO monad you use. The same could be said for the Test.IOSpec modules. However, the Test.IOSpec also give you a pure specification of the functions you are using. This is very important if you want to trace/debug an execution of you code - you can see how the state of your machine changes at every step. There's also a bit finer control over how you test your functions: concurrent code is parameterised over the scheduler, for instance. Both these aren't possible with the RIO approach. > P.S. why >> *If you're an ICFP referee, you may want to avoid reading any >> further* ICFP has a double-blind review process: if I were to submit a paper, I should do so anonymously. The idea behind it all is that if the reviewers don't know who the author of a paper is, they can't be prejudiced. The code I just released is described in a paper submitted to ICFP. All the best, Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

ICFP Programming Contest 2007
by Johan Jeuring 25 Apr '07

25 Apr '07

Want to show off your programming skills? Your favorite programming language? Your best programming tools? Join the ICFP Programming Contest 2007! The 10th ICFP Programming Contest celebrates a decade of contests. This is one of the world's most advanced and prestiguous programming contest you can enter. For free! Book July 20 - 23, 2007. Check out http://www.icfpcontest.org/.

1 0

Is there a best *nix or BSD distro for Haskell hacking?
by David Cabana 25 Apr '07

25 Apr '07

I have a spare Windows machine I want to put to better use. I want to turn it into a Haskell hacking box, and was wondering whether any particular *nix or BSD distribution is best (or worst) suited for this. Any thoughts? Thank you, David Cabana

13 14

About functional programing, type theory and a master thesis topic
by Glauber Cabral 25 Apr '07

25 Apr '07

Hi everybody =) First time I write to the list. My name is Glauber and I'm doing my master course at UNICAMP, Brazil, under supervisor of Prof. Dr. Arnaldo Vieira Moura. I'm interested in Haskell, type theory and algebraic specification (formal methods). I've been studying these subjects to my Computer-Science-Bachelor-degree-final work. It was an implementation of an homomorphism between a little constructive algebraic specification code (based mainly in Loeckx's Specification of Abstract Data Types) and a Haskell code. SableCC was used as tool to implement the interpreter because I've already used it before. One theme to work one should be implementing this in Haskell itself, but there is already HasCASL. I've already contacted the HasCASL professors and I'm reading more about the project. At the same time, I want to look for some theme under type theory, too. The main concern about HasCASL is that I want to get in deep touch with functional programming during my master thesis and I'm not sure (yet) if studying HasCASL would get me there. I've reading some papers about type theory and Haskell (mainly the ones suggested in the haskell.org site) and as I could see the topics are very interesting. I'm not sure, however, if there is something that can be done in a 2-year-master course. Mainly, they propose new extensions that have became new languages (Cayenne, Omega and Epigram). Other topic I'd like to get in touch is theorem proving. As I could see, Coq and Isabelle are the most used with Haskell. Indeed, HasCASL use Isabelle and this could be a nice thing to work on, as was suggested by HasCASL professors. As I know that lots of you here are researchers, I'd like to ask some opinions about what can be done as a master thesis having in mind that I want to continue in a PhD course after the master one. Sorry if the email is too large. And thank for the patience and for any opinion you can give me. Yours, Glauber.

2 4

Newbie seeking advice regarding data structure for a tricky algorithm
by Toby Hutton 25 Apr '07

25 Apr '07

Hi, I'm trying to implement a fast kd-tree in Haskell. http://en.wikipedia.org/wiki/Kd-tree It's a binary tree representing space partitions. One of the fastest ways to build kd-trees is outlined in this paper: http://www.cgg.cvut.cz/~havran/ARTICLES/ingo06rtKdtree.pdf (I'm trying to implement Algorithm 5 on page 5 and the steps outlined in section 4.3.1.) I'll try to outline a simplified analogous algorithm to demonstrate my problem. It's all about classifying which children should go in a left or right branch using heuristics. Say I want to put the words 'foo', 'bar' and 'baz' into a binary tree. The heuristic requires I split the words into letters and sort them: 'aabbfoorz'. The heuristic then may decide, based on the sorted letters, that 'bar' and 'foo' should go in the left child and 'baz' goes in the right. Typically we'd then simply recurse and for example, the left child's words would be re-sorted into 'abfoor' and the heuristic is reapplied. If we assume that sorting is relatively expensive, we can avoid the re-sort for the children by unmerging the parent's sorted list of letters. Two sublists of a sorted list should already be sorted. If we know which word each letter belongs to it would be more efficient to tag the letters with 'left' or 'right' as the words are classified. Then we can iterate down the sorted letter list and produce new sorted sublists rather simply. So it's not actually that complicated, and I can imagine exactly how it could be done in C but I really don't know how to approach this in Haskell. The problem I'm having is how to keep a map between the words and its letters (which in the real problem is a map between a list of vectors and 6 tuples containing Doubles and enumerations) while keeping in mind you can't just map any letter to a word, but specific letters. e.g., the 'b's in the example must remember specifically whether they belong to 'bar' or 'baz'. Thanks for any insights, Toby.

3 2

Haskell version of Norvig's Python Spelling Corrector
by Pete Kazmier 25 Apr '07

25 Apr '07

Recently I read an interesting article by Peter Norvig[1] on how to write a spelling corrector in 21-lines of Python. I wanted to try and implement it in Haskell. My implementation is terribly slow and I was hoping for some tips on how to improve it and make it idiomatic. I'd love to see other Haskell implementations as well if anyone has a few moments to spare. Admittedly, it took me several hours to get my version working, but I'm a Haskell newbie. Unfortunately, I think it runs as slow as it took me to write it! There is definitely something wrong with it, a memory leak, because I can't correct more than a few words without a great deal of memory being consumed. Thanks, Pete [1] http://norvig.com/spell-correct.html

10 21

Is Template Haskell a suitable macro language?
by Joel Reymont 25 Apr '07

25 Apr '07

I'm finding myself dealing with several large abstract syntax trees that are very similar in nature. The constructor names would be the same or one type may be a small extension of another. This is something that I wouldn't worry about with Lisp, for example, as I would create a bunch of macros for creating syntax trees and reuse them all over. I cannot do this in Haskell, though, as my "macros" are functions and so I must repeat them for every AST since they return different types. I'm wondering if Template Haskell is a suitable replacement for Lisp macros. What is the consensus? Thanks, Joel -- http://wagerlabs.com/

5 5

Re: haskell question
by oleg＠pobox.com 24 Apr '07

24 Apr '07

Greg Meredith wrote: > The file compiles with ghc as is. If you uncomment the last > section, however, you see that to close the loop on the constraints for the > agent syntax we hit a typing error. i <b><i>think</i></b> this is a hard > constraint in Haskell that prevents this level of generality in the > specification, but maybe you can see a way around it. I believe the Haskell typechecker is right > instance (Eq n, Eq p) => > CoreAgentSyntax (MinimalAgentSyntax n p) where > bind [] proc = Thunk (\() -> proc) > > data MinimalAgentSyntax n p = > Thunk (() -> p) > | Abstraction ([n] -> p) > | Concretion [n] p The bind method has the signature bind :: (CoreProcessSyntax p, CoreAgentSyntax x) => [n] -> (p a x) -> x That is: for any agent x and for _any_ process p (regardless of x), we should be able to perform the bind operation. The signature for bind proclaims total independence between 'p' and 'x'. However, when we define the instance > CoreAgentSyntax (MinimalAgentSyntax n p) where > bind [] proc = Thunk (\() -> proc) we see that process proc and the agent aren't totally independent: the result of bind has the type 'MinimalAgentSyntax n process' and thus is dependent on the 'process == p a x'. We have broken our previously made independence proclamation, and so the typechecker rightfully complaints. The following is one solution. It works sans the line marked TODO. I'm not sure that line is correct: -- -- TODO : lgm : need to substitute m for n in proc -- bind (name:names) proc = Abstraction (\m -> bind names proc) According to the type of Abstraction, 'bind names proc' should have the type 'p', that is, the same type as proc. It should be a process. OTH, bind returns an agent. Something is amiss here. {-# OPTIONS -fglasgow-exts #-} module Core where -- What's in a name? class Nominal n where nominate :: i -> n i newtype Name i = Nominate i deriving Eq instance Nominal Name where nominate i = Nominate i -- Where are we? class Locality a where locate :: (Eq s, Nominal n) => s -> (n i) -> a s (n i) name :: (Eq s, Nominal n) => a s (n i) -> (n i) data Location s n = Locate s n deriving Eq instance Locality Location where locate s n = Locate s n name (Locate s n) = n -- Constraints class CoreProcessSyntax p a x | p -> a x where zero :: p sequence :: a -> x -> p compose :: [p] -> p class CoreAgentSyntax x p n | x -> p n where bind :: [n] -> p -> x offer :: [n] -> p -> x -- Freedom (as in freely generated) data MinimalProcessSyntax l x = Null | Sequence l x | Composition [MinimalProcessSyntax l x] data MinimalAgentSyntax n p = Thunk (() -> p) | Abstraction ([n] -> p) | Concretion [n] p -- Constraining freedom instance CoreProcessSyntax (MinimalProcessSyntax l x) l x where zero = Null sequence l a = Sequence l a compose [] = zero compose ps = Composition ps instance CoreAgentSyntax (MinimalAgentSyntax n p) p n where bind [] proc = Thunk (\() -> proc) -- -- TODO : lgm : need to substitute m for n in proc -- bind (name:names) proc = Abstraction (\m -> bind names proc) -- here's the possible implementation. I don't know if it's right. -- But at least it types bind (name:names) proc = Abstraction (\m -> comp $ bind names proc) where comp (Thunk f) = f () -- comp (Concretion n p) = ... offer names proc = Concretion names proc

2 3

QuickCheck testing of AST transformers
by Joel Reymont 24 Apr '07

24 Apr '07

My previous post did not receive any replies so I thought I might try generalizing the problem a bit... Suppose I'm parsing a language into a syntax tree and then transforming that tree into another AST representing a "core language". The core language is a more general AST that should help with compiling to other languages. My problem is how to best structure my AST transformations to be able to test them with QuickCheck. I suspect that I'm not going about it in the most optimal way so I thought I should ask for suggestions. The transformation into the core AST applies operations to simplify, or desugar, the AST of the original language. Here's sample code in the source language which, incidentally, was recently highlighted at Lambda the Ultimate [1]. Array: MyArray[10](10 + 2); Value1 = MyArray[5][10]; This declares an array of 10 elements and initializes each element to 12. Value1 (a built-in variable) is then initialized to the value of element #5 as of 10 bars ago. A bar is, basically, a stock quote. The code is invoked on every bar and so "5 bars ago" can be treated as 5 invocations ago. The syntax tree of the above code is a 1-1 mapping. We declare an array of integers of 10 elements. Initialize it to the sum of two integers and then assign to Value1. [ ArrayDecs [ VarDecl (VarIdent "MyArray") TyInt [Int 10] (Op Plus (Int 10) (Int 2)) ] , Assign (VarIdent "Value1") [] (Var (VarIdent "MyArray") [Int 5] (BarsBack (Int 10))) ] The "desugared" version does away with the array declaration statement and declares MyArray to be a variable of array type. Arrays in the "core language" do not remember values from one invocation to another but there's a data series type, so we declare a series variable to hold the value of element #5. We must manually store the value of the array element in the data series and can then refer to the value of the series 10 data points ago. vars = [ ("MyArray", VarDecl (TyArray TyInt) [Int 10] (Just (Plus (Int 10) (Int 2)))) , ("series0", VarDecl (TySeries TyInt) [] Nothing) ] code = [ AddToSeries (VarIdent "series0") (Var (VarIdent "MyArray") [Int 5]) , Assign (Var (VarIdent "Value1") []) (Series (VarIdent "series0") (Int 10)) ] The next step would be to take the above "core syntax tree" and transform it yet again into a C# (or other target language) AST. It's assumed that all target languages have a data series type. The OCaml version of my code translated directly into the C# AST but I figured an intermediate syntax tree will help me translate into other languages such as Haskell, Erlang or OCaml. The part I can't figure out is how to come up with a set of invariants for my transformations. Should I, for example, state that every access to an array value in a previous invocation should introduce an extra variable to hold the series plus the appropriate assignment code? Should I write the translator as a series of small transformers in the ST monad that can be threaded and tested separately? Thanks in advance, Joel [1] http://lambda-the-ultimate.org/node/2201 -- http://wagerlabs.com/

3 2

Re: [Haskell-cafe] QuickCheck testing of AST transformers
by Thomas Schilling 24 Apr '07

24 Apr '07

Additionally, as a safety net, you might want to type-check the code that's being produced by your Arbitrary instances and state some invariants on your code. Also, you'll likely want to limit your number of evaluation steps if your language allows non-terminating programs. In any case, QuickCheck may not get you far enough to gain enough confidence, so proving properties by hand (after you made sure that QuickCheck doesn't find any counter-examples, of course) can give you interesting insights, since, this way, you have to take a look at all the possible cases yourself. /Thomas On 24 apr 2007, at 00.05, Lennart Augustsson wrote: > Without looking into your language and transformation in more > detail it's hard to come up with concrete suggestions. But here > are some anyway: > > Write an interpreter for each of your languages (original AST, > transformed AST) etc, and then use a quickcheck property stating > that well formed programs have the same denotation before and after > transformation, i.e., the two interpreters give the "same" value > (you might need some relaxed notion of same). > > You transformations are trying to get rid of some language > construct, I presume. So you can have some properties stating that > they will be gone in the transformed program.. > > -- Lennart > > > On Apr 23, 2007, at 22:46 , Joel Reymont wrote: > >> My previous post did not receive any replies so I thought I might >> try generalizing the problem a bit... >> >> Suppose I'm parsing a language into a syntax tree and then >> transforming that tree into another AST representing a "core >> language". The core language is a more general AST that should >> help with compiling to other languages. >> >> My problem is how to best structure my AST transformations to be >> able to test them with QuickCheck. I suspect that I'm not going >> about it in the most optimal way so I thought I should ask for >> suggestions. >> >> The transformation into the core AST applies operations to >> simplify, or desugar, the AST of the original language. Here's >> sample code in the source language which, incidentally, was >> recently highlighted at Lambda the Ultimate [1]. >> >> Array: MyArray[10](10 + 2); >> Value1 = MyArray[5][10]; >> >> This declares an array of 10 elements and initializes each element >> to 12. Value1 (a built-in variable) is then initialized to the >> value of element #5 as of 10 bars ago. A bar is, basically, a >> stock quote. The code is invoked on every bar and so "5 bars ago" >> can be treated as 5 invocations ago. >> >> The syntax tree of the above code is a 1-1 mapping. We declare an >> array of integers of 10 elements. Initialize it to the sum of two >> integers and then assign to Value1. >> >> [ ArrayDecs [ VarDecl (VarIdent "MyArray") TyInt [Int 10] >> (Op Plus (Int 10) (Int 2)) ] >> , Assign (VarIdent "Value1") [] (Var (VarIdent "MyArray") [Int 5] >> (BarsBack (Int 10))) ] >> >> The "desugared" version does away with the array declaration >> statement and declares MyArray to be a variable of array type. >> Arrays in the "core language" do not remember values from one >> invocation to another but there's a data series type, so we >> declare a series variable to hold the value of element #5. >> >> We must manually store the value of the array element in the data >> series and can then refer to the value of the series 10 data >> points ago. >> >> vars = [ ("MyArray", VarDecl (TyArray TyInt) [Int 10] >> (Just (Plus (Int 10) (Int 2)))) >> , ("series0", VarDecl (TySeries TyInt) [] Nothing) >> ] >> >> code = [ AddToSeries (VarIdent "series0") (Var (VarIdent >> "MyArray") [Int 5]) >> , Assign (Var (VarIdent "Value1") []) >> (Series (VarIdent "series0") (Int 10)) >> ] >> >> The next step would be to take the above "core syntax tree" and >> transform it yet again into a C# (or other target language) AST. >> It's assumed that all target languages have a data series type. >> >> The OCaml version of my code translated directly into the C# AST >> but I figured an intermediate syntax tree will help me translate >> into other languages such as Haskell, Erlang or OCaml. >> >> The part I can't figure out is how to come up with a set of >> invariants for my transformations. >> >> Should I, for example, state that every access to an array value >> in a previous invocation should introduce an extra variable to >> hold the series plus the appropriate assignment code? >> >> Should I write the translator as a series of small transformers in >> the ST monad that can be threaded and tested separately? >> >> Thanks in advance, Joel >> >> [1] http://lambda-the-ultimate.org/node/2201 >> >> -- >> http://wagerlabs.com/ >> >> >> >> >> >> _______________________________________________ >> 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

ANN: template 0.1 - Simple string substitution
by Johan Tibell 24 Apr '07

24 Apr '07

As an exercise I wrote a simple string substitution library that supports "$"-based substitution ala Perl or Python. Example usage: > import qualified Data.ByteString.Lazy.Char8 as B > import Text.Template > > context = Map.fromList . map packPair > where packPair (x, y) = (B.pack x, B.pack y) > > helloTemplate = B.pack "Hello, $name! Want some ${fruit}s?" > helloContext = context [("name", "Johan"), ("fruit", "banana")] > > main = B.putStrLn $ substitute helloTemplate helloContext Hopefully this is useful for someone who needs something more readable than Text.Printf's "%s"-based substitution or string concatenation for longer strings but less than a full blown templating system like the ones found in most web frameworks. Release: http://www.johantibell.com/template/template-0.1.tar.gz Source: darcs get http://darcs.johantibell.com/template Once we get ByteString literals most of the noise in the above example will disappear. In the mean time it's probably a good idea to write utility function like "context" above when you prefer a convenient String interface to a somewhat faster ByteString interface. It would be great if someone could do a code review and add it to Hackage if it looks OK. I'll really appreciate the feedback. Also, I'm not 100% sure how to make the haddock links work with Hackage so they link to the library docs. Is this something done at upload time? Here are some open issues: * I currently use my own ByteString parser. Data.Binary almost does what I need. Basically I need takeWhile and two chars of look-ahead. * I would like to only depend on base, currently I use State so I depend on mtl. Cheers, Johan

1 0

Announce: DisTract: Distributed Bug Tracker implemented in Haskell
by Matthew Sackman 24 Apr '07

24 Apr '07

DisTract is a Distributed Bug Tracker. We're all now familiar with working with distributed software control systems, such as Monotone, Git, Darcs, Mercurial and others, but bug trackers still seem to be fully stuck in the centralised model: Bugzilla and Trac both have single centralised servers. This is clearly wrong, as if you're able to work on the Train, off the network and still perform local commits of code then surely you should also be able to locally close bugs too. DisTract allows you to manage bugs in a distributed manner through your web-browser. Currently only Firefox is supported. The reason for this is that there is no local server used, and so the web-browser must directly (via Javascript) call programs on your local system. I only know how to do this in Firefox. The distribution is achieved by making use of a distributed software control system, Monotone. Thus Monotone is used to move files across the network, perform merging operations and track the development of every bug. Finally, the glue in the middle that generates the HTML summaries and modifies the bugs is written in Haskell. The first version, 0.1 has just been released. There are missing features currently, and I've only tested it on Linux. However, it should work on OS X and Windows if you can make it compile! It's only been tested with Monotone version 0.33. http://www.distract.wellquite.org/ Many thanks, Matthew

2 1

New York Functional Programmers Network Inaugural Meeting - Thurs day May 3rd 2007 from 6pm
by Mansell, Howard 24 Apr '07

24 Apr '07

We are starting up a New York area-based network for functional programmers. The idea is to have a regular meeting through which functional programmers can meet to discuss experiences, get and give information, find jobs etc. The first official meeting will be held on Thursday May 3rd at the offices of Credit Suisse in Manhattan, from 6pm to ~8pm. The meeting is intended to be an informal gathering and refreshments will be provided to make the experience even more pleasant. Please let me know if you would like to attend so that I can make sure we have a large enough room and adequate libation. Howard Mansell (Credit Suisse) Jeff Polakow (Deutsche Bank) ============================================================================== Please access the attached hyperlink for an important electronic communications disclaimer: http://www.credit-suisse.com/legal/en/disclaimer_email_ib.html ==============================================================================

1 0

Performance and STUArrays
by Dominic Steinitz 24 Apr '07

24 Apr '07

I've been playing around some more trying improve the performance of the SHA1 implmentation in the crypto library. I've isolated one of the functions and implemented it using a) unfold and b) STUArray The STUArray implementation is about twice as fast but I was expecting an order of magnitude improvement given I thought I would have been allocating 16 x 80 new 32 bit words with unfold but nothing with the STUArray. Should I have been disappointed? dom@heisenberg:~/sha12> time ./arrTest 17 STUArray > /dev/null real 0m11.102s user 0m9.129s sys 0m0.112s dom@heisenberg:~/sha12> time ./arrTest 17 Unfold > /dev/null real 0m18.381s user 0m16.361s sys 0m0.212s Dominic. import Data.Bits import Data.List import Data.Word import Control.Monad.ST import Data.Array.ST import System import System.IO data Word160 = Word160 !Word32 !Word32 !Word32 !Word32 !Word32 deriving (Eq, Show) ss :: Word160 ss = Word160 0x67452301 0xefcdab89 0x98badcfe 0x10325476 0xc3d2e1f0 test :: [Word32] test = [0x61626380, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000018] tests :: Int -> [[Word32]] tests n = map (\n -> n:[0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18]) [1..2^n] rotL :: Bits b => Int -> b -> b rotL = flip rotateL v1 :: a -> [Word32] -> [Word32] v1 ss xs = take 80 (n xs) where h [w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15] = Just (w0,[w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15, (rotL 1 (w0 `xor` w2 `xor` w8 `xor` w13))]) n = unfoldr h v2 ss xs = vs where us = do w <- newArray (0,79) 0 :: ST s (STUArray s Int Word32) let initLoop 15 = writeArray w 15 (xs!!15) initLoop n = do writeArray w n (xs!!n) initLoop (n+1) mainLoop 79 = nextW 79 mainLoop n = do nextW n mainLoop (n+1) nextW n = do wm16 <- readArray w (n-16) wm14 <- readArray w (n-14) wm8 <- readArray w (n-8) wm3 <- readArray w (n-3) writeArray w n (rotL 1 (wm3 `xor` wm8 `xor` wm14 `xor` wm16)) initLoop 0 mainLoop 16 getElems w vs = runST us test1 n = map (v1 ss) (tests n) test2 n = map (v2 ss) (tests n) data TestType = Unfold | STUArray deriving (Eq, Read, Show) main = do progName <- getProgName args <- getArgs if length args /= 2 then putStrLn ("Usage: " ++ progName ++ " <testSize> <testType>") else do let n = read (args!!0) t = read (args!!1) if t == Unfold then putStrLn (show (test1 n)) else putStrLn (show (test2 n))

3 2

Creating QuickCheck properties
by Joel Reymont 23 Apr '07

23 Apr '07

Folks, I have code like this that I want to test with QuickCheck but I'm having trouble imagining how I would wrap it up in a property. Do I make sure that id, subs, back are always morphed properly or do I leave that to separate properties for their respective types? Do I then ensure that array types are always unwrapped (see getType below), that a "series" variable is always declared, code added and a series reference returned? Last but not least, is monadic testing part of Test.QuickCheck.*? Thanks, Joel type Core a = State CoreUnit a data CoreUnit = Core { coreSym :: Integer -- starting # for gensym , coreVars :: M.Map String VarDecl , coreCode :: M.Map Integer [Statement] } deriving (Show, Eq) morphHistArrayAccess :: VarIdent -> Subscript -> BackRef -> C.Core C.Expr morphHistArrayAccess id subs back = do id' <- morph id subs' <- morph subs back' <- morph back (C.TyArray ty) <- getType id' s <- genSym "series" addVar s (C.TySeries ty) [] Nothing addCodeFront 1 [ C.AddToSeries (C.VarIdent s) (C.Var id' subs') ] return $ C.Series (C.VarIdent s) back' -- http://wagerlabs.com/

1 0

Gotta love Haskell
by Justin Bailey 23 Apr '07

23 Apr '07

My wife has been put in charge of scheduling lectors and ministers at our church, so of course she needs a Haskell program to do the schedules for her! While I've been working on it, I wrote something that I thought was a pretty cool trick. Each Mass requires a variety of different type and number of participants, so when defining the "Mass" data structure I put a function in which selects participants for that type of Mass from a given list: data MassTime = MassTime { ... selectParticipants :: (Participants -> Maybe Participants), -- Picks participants for this mass ... } Each mass has particular requirements. Notice the 'selectParticipants' function does not take a mass definition as an argument. Here's the trick I thought was neat. When creating the MassTime value, I capture it in a closure and bind it to the selector function, as below: makeMass :: Day -> MassTime makeMass day = mass where -- Use trick here to capture mass defined and pass to our selection function. mass = MassTime ... (weekendMassSelector mass) ... 'weekendMassSelector' is defined elsewhere, and basically knows how to count up the right number of participants based on the mass definition given. It's signature is: weekendMassSelector :: MassTime -> Participants -> Maybe Participants So weekendMassSelector gets the MassTime value it needs, before it is even constructed. Partial evaluation then gives a function with the (Participants -> Maybe Participants) signature required by the data constructor. I love Haskell - this just seems too cool. Since I really doubt this is something new - is this a technique that's commonly used? Does it have a name? It looks a lot like passing a "this" argument to a function - have I re-invented OOP encapsulation? :) Justin

2 1

newbie question on ordering
by Nikolay Metchev 23 Apr '07

23 Apr '07

Hello guys, I have decided to try and get back into Haskell recently. I have used it in the past but have forgotten large chunks. I am trying to express the logic of a particular card game. For this purpose I need to be able to order cards in various orders. At first I thought that the Ord class was my answer but I found it very verbose. Below is my best attempt so far but I can't help but feel it too is verbose and that there must be a better way of comparing cards in different orders. data Face = Ace | Two | Three | Four | Five | Six | Seven | Eight | Nine | Ten | Jack | Queen | King deriving (Enum, Show, Eq) data Suit = Clubs | Diamonds | Hearts | Spades deriving (Show, Enum, Eq) type Card = (Face, Suit) listComparator :: (Eq a) => [a] -> a -> a -> Ordering listComparator xs a b = compare x y where x = elemIndex a xs y = elemIndex b xs sequentialBonusFaceOrder :: [Face] sequentialBonusFaceOrder = [Seven, Eight, Nine, Ten, Jack, Queen, King, Ace] fourOfAKindBonusFaceOrder :: [Face] fourOfAKindBonusFaceOrder = [Queen, King, Ten, Ace, Nine, Jack] sequentialBonusFaceComparator :: Face -> Face -> Ordering sequentialBonusFaceComparator = listComparator sequentialBonusFaceOrder fourOfAKindBonusFaceComparator :: Face -> Face -> Ordering fourOfAKindBonusFaceComparator = listComparator fourOfAKindBonusFaceOrder The problem with this approach is that if you want to compare you to write things of the following nature: fourOfAKindBonusFaceComparator f1 f2 == GT this isn't very clear especially if you want "<=" you have to do fourOfAKindBonusFaceComparator f1 f2 /= GT Any suggestions would be nice.

3 2

question about Data.Binary and Double instance
by David Roundy 23 Apr '07

23 Apr '07

Hi all, I'm wondering what exactly inspired the decode/encodeFloat implementation for Data.Binary? It seems to me like it'd be much better to use a standard format like IEEE, which would also be much more efficient, since as far as I know, on every implementation a Double and a CDouble are identical. Are there any suggestions how I could use Data.Binary to actually read a binary file full of Doubles? Should I just use the Array interface, and forget laziness and hopes of handling different-endian machines? Or is there some way to reasonably do this using Data.Binary? -- David Roundy Department of Physics Oregon State University

6 15

ANNOUNCE: xmonad 0.1
by Spencer Janssen 22 Apr '07

22 Apr '07

The xmonad dev team is pleased to announce the inaugural release of: xmonad: a tiling window manager http://xmonad.org Xmonad is a minimalist tiling window manager for X, written in Haskell. Windows are managed using automatic layout algorithms, which can be dynamically reconfigured. At any time windows are arranged so as to maximise the use of screen real estate. All features of the window manager are accessible purely from the keyboard: a mouse is entirely optional. Xmonad is configured in Haskell, and custom layout algorithms may be implemented by the user in config files. A principle of Xmonad is predictability: the user should know in advance precisely the window arrangement that will result from any action. By default xmonad provides three layout algorithms: tall, wide and fullscreen. In tall or wide mode, windows are tiled and arranged to prevent overlap and maximise screen use. Sets of windows are grouped together on virtual screens, and each screen retains its own layout, which may be reconfigured dynamically. Multiple physical monitors are supported via Xinerama, allowing simultaneous display of a number of screens. By utilising the expressivity of a modern functional language with a rich static type system, Xmonad provides a complete, featureful window manager in less than 500 lines of code, with an emphasis on correctness and robustness. Internal properties of the window manager are checked using a combination of static guarantees provided by the type system, and type-based automated testing. A benefit of this is that the code is simple to understand, and easy to modify. More information, screenshots, documentation and community resources are available from: http://xmonad.org Xmonad is available from hackage, and via darcs. Happy hacking! The Xmonad Team: Spencer Janssen Don Stewart Jason Creigh

1 0

Lessons from memory leak in streaming parser
by Oren Ben-Kiki 22 Apr '07

22 Apr '07

First, let me thank all the people who responded to my issue, it was very helpful. I would have responded earlier but I was on a business trip and out of contact for the last week. On the bright side I used the time to re-work my implementation. Instead of relying on Haskell's lazy evaluation, elegant as it may be, I changed it to use a continuation passing style. Every invocation of the parser returns a few tokens and a parser for the rest of the input. Interestingly, this approach maps well to non-lazy languages - basically anything that supports closures - unlike the original method that relied on lazy evaluation. So in principle I can now convert the Haskell code to Scheme, Ruby, or even JavaScript. At any rate, once I have done that, things started to fall into place. I still had minor leaks, but the results of profiling were actually proving useful for a change. I needed to turn off lazy evaluation in several key places (almost all record fields are now strict, and a 'seq' was needed in one crucial location). The result is a parser that can handle anything you throw at it with constant (reasonably low) memory usage. It is dog-slow (about 8k/sec, or twice that if compiling with -O2) but I was expecting that. So, lesson learned - lazy evaluation in Haskell is a very nice feature, but extremely difficult to debug, profile and control. Using continuations may be less elegant at places, but is much more practical. You can see the final result in version 0.3 of the YamlReference package I just uploaded to the Cabal database. This is intended to be an "executable version" of the YAML specification (the BNF file, which is actually Haskell code, is almost exactly the list of spec BNF productions). Thanks again for all the help, Oren Ben-Kiki

1 0

Installation of hs-plugins
by Philipp Volgger 21 Apr '07

21 Apr '07

Hello everybody, could somebody please tell me how hs-plugins has to be installed. I tried it with hs-plguin 1.0rc1 and I was unable to build it. I did runhaskell Setup.lhs configure runhaskell Setup.lhs build (Crash without any information) I tried it wiht GHC 6.4, 6.4.1 and 6.6. I am using Windows XP with SP2.

2 2

anyone interested in developing a Language.C library?
by Duncan Coutts 21 Apr '07

21 Apr '07

Hi all, If anyone is interested in developing a Language.C library, I've just completed a full C parser which we're using in c2hs. It covers all of C99 and all of the GNU C extensions that I have found used in practise, including the __attribute__ annotations. It can successfully parse the whole Linux kernel and all of the C files in all the system packages on my Gentoo installation. It's implemented as an alex lexer and a happy parser. The happy grammar has one shift/reduce conflict for the dangling if/then/else issue (which could be hidden by using precedence but it's clearer not to). So if someone is interested in developing a more widely usable Language.C library, I think this would be a good place to start. There's plenty to do however: * The c2hs C AST is ok but probably not enough for a general purpose library. * The parser currently uses some other c2hs infrastructure which would need disentangling to pull the parser out (mostly identifiers and unique name supply management). * It does not record everything into the parse tree, eg __attribute__s are parsed but ignored. * It does no semantic analysis after parsing (though other bits of c2hs to a very little) * In at least one place the parser is deliberately too liberal (to avoid ambiguities) which would require simple extra checks after parsing to detect. * The lexical syntax has not been checked against the spec fully, it is probably over-liberal in some cases. * I've not done much performance work, the lexer has not been seriously tuned, it still lexes via a String. Having said that, the performance is not at all bad, on a 3Ghz box it does ~20k lines/sec. * The parser error messages are terrible (it might be interesting to try porting from happy to frown for this purpose) There's probably more stuff, but that's what I can think of right now. So if anyone is interested then let me know, I can give some pointers (hopefully the useful kind, not the void * kind). You can get the code from the c2hs darcs repo: darcs get --partial http://darcs.haskell.org/c2hs/ The C parser bits are under c2hs/c/ Duncan Licensing: It's not 100% clear. At the moment it's marked as GPL, but it's derived from several sources so we need to be careful about that. Personally I'm happy to use LGPL. It derives from c2hs obviously, which is GPL, though we could enquire about re-licencing, especially since there is very little of c2hs stuff used in it any more. It also derives partly from James A. Roskind's C grammar (in particular the grammar of declarations). His copyright license is fairly liberal but this need double-checking. It also derives from the C99 spec and I read the comments in the gcc C parser as a guide to GNU C's extensions to the C grammar (no code or comments were copied however). Testing: I tested it thus far by writing a little gcc wrapper script, so you can build any ordinary bit of C software using this wrapper and it'll call gcc with the same args but it'll also try and parse the input file. It reports into a log file. I've not tried the gcc C parser testsuite. This approach is probably good for other tests like trying to see if parsing and pretty printing can round-trip correctly; if not identical token streams (since parsing drops redundant brackets etc) checking if gcc produces identical .S/.o files. Something that c2hs needs is to calculate sizes of types and structure member offsets correctly. This is also something that could be tested in this style, by comparing on thousands of example .c files with what gcc thinks.

4 4