Haskell Weekly News

Haskell Weekly News: September 27, 2006

Submitted by dons on Wed, 09/27/2006 - 12:42am.

Welcome to issue 42 of HWN, a weekly newsletter covering developments in the Haskell community. Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

This week we see a new Hugs release, and the results of the ICFP contest are out! We feature a special report on the Commercial Users of Functional Programming workshop, courtesy of John Hughes


  • ICFP Contest Results. CMU's Principles of Programming Group announced the results of this year's ICFP programming contest. Congratulations to the winning team from Google, 'Team Smartass', (Christopher Hendrie, Derek Kisman, Ambrose Feinstein and Daniel Wright), who used Haskell along with C++, Bash and Python. Haskell has now been used by the winning team three years running! An honourable mention to team Lazy Bottoms, another Haskell team, who managed to crack several of the puzzles first. Five teams from the #haskell IRC channel were placed in the top 50. A video stream of the results announcement is available, shot and cut by Malcolm Wallace. Many thanks to the CMU team for organising such a great contest!

  • New release of Hugs. Ross Paterson announced a new minor release of Hugs, fixing a few bugs with the May 2006 release, and with libraries roughly matching the forthcoming GHC 6.6 release. It is available from the Hugs page.

  • HAppS version 0.8.2. Einar Karttunen announced the release of the Haskell Application Server version 0.8.2. HAppS is a Haskell web application server for building industrial strength internet applications safely, quickly, and easily. With HAppS you focus entirely on application functionality implemented in your favourite language and you don't have to worry about making sure all sorts of server subsystems are functioning properly. More info.

  • Codec.Compression.GZip and .BZip. Duncan Coutts released two new packages: zlib and bzlib, which provide functions for compression and decompression in the gzip and bzip2 formats, directly on ByteStrings. Both provide pure functions on streams of data represented by lazy ByteStrings. This makes it easy to use either in memory or with disk or network IO. There is API documentation is available here and here.

  • System Fc branch merged into GHC. Manuel Chakravarty merged the System Fc branch of GHC into GHC head. This is a significant development, adding extensions to GHC to support an FC-based intermediate language, a new implementation of GADTs, along with indexed data types and indexed newtypes (generalised associated data types). More details about the implementation.

  • Job writing security software in Haskell. Andrew Pimlott announced that Planning Systems, Inc. has a job opportunity for Haskell programmers, writing a high-assurance authorization system. Job description.

  • Dr Haskell 0.1. Neil Mitchell released Dr Haskell, a tool to help suggest improvements to your Haskell code. Dr Haskell will analyse your code, and suggest shorter alternatives for rewriting. More details.

  • BitSyntax for Haskell. Adam Langley released a bit syntax library for Haskell, based on Erlang's bit syntax (great for building and breaking up binary structures). Nice!

  • File fuzzing. Tim Newsham made available FileH, a Haskell tool for generating test data via random file mutation. More details.

  • A DSL for state machines. Stephane Bortzmeyer announced a Haskell implementation of a proposal to the IETF to standardize a language used for finite state machines (which are common in IETF standards). The reference implementation is available.

  • A language tag parser. Stephane Bortzmeyer announced GaBuZoMeu, a set of programs to parse and check language tags (see RFC 4646 produced by the IETF Working Group LTRU - Language Tag Registry Update).


This section covers the Haskell' standardisation process.

Conference roundup

The Commercial Users of Functional Programming workshop (CUFP), held in association with ICFP, attracted a record turn-out this year. 57 attendees came to listen to 9 speakers talk about commercial uses of Scheme, Erlang, Reflect, OCaml, and Haskell. Four of the speakers talked about applications of Haskell.
  • Linspire in Haskell. Clifford Beshers talked about the adoption of Haskell at Linspire. Linspire switched recently from OCaml to Haskell, citing readability, classes, the IO monad, and more complete libraries as reasons. So far CGI scripts and a package autobuilder have been implemented in Haskell. Static typing, and the use of purely functional data structures on disk, have helped make for reliable code. Performance has been generally good, although Parsec parsers proved to be slow on larger files--a problem that was solved using Data.ByteString. Space leaks have not been a problem, perhaps because frequent IO keeps programs strict. Belying the myth that functional programmers are hard to recruit, Linspire's announcement that they were adopting Haskell generated several resumes, despite explicitly stating that they were not recruiting.

  • Haskell programming at Credit Suisse. Howard Mansell talked about Haskell programming at Credit Suisse in New York. This group's business is derivative trading for clients. Valuing complex derivatives is computationally costly, requiring nightly runs on thousands of CPUs. There is a real competitive advantage in being able to build models quickly, since some exotic derivatives may only be traded 10-100 times in total. Previously models were built using Excel, with heavy computations delegated to C++ plugins. Most of the Excel code has now been replaced by Haskell, with Excel just providing the user interface (which in turn is generated by DSELs). The work has been done by Lennart Augustsson and Gabriele Keller, but Credit Suisse needs more Haskell programmers -- they're hiring.

  • Hardware design at Bluespec Inc.. Rishiyur Nikhil talked about Bluespec Inc, which offers System Verilog tools implemented in about 90K loc of Haskell. Bluespec's tools are based on MIT research in the 90s into generating hardware from term rewriting systems; using Bluespec's 'rules' complex hardware can be described at a high level, improving productivity and reducing errors. Selling the tools based on Haskell requires short, punchy examples to convince old hands that there is a better way than writing RTL by hand. Bluespec have started sales, and many more trials are under way.

  • Aetion, AI and Haskell. Garret Morris talked about Haskell applications at Aetion, which is a defence contractor offering AI applications based on Bayesian nets. Rapidly changing priorities make it important to minimize the code impact of changes, which suits Haskell well. Aetion have developed three main projects in Haskell, all successful. Haskell's concise code was perhaps most important for rewriting: it made it practicable to throw away old code occasionally. DSELs allowed the AI to be specified very declaratively. Less successful was the decision to link Haskell to a GUI in Java: the need to serialize data made it impossible to use functions as representations, which was unfortunate. Other issues included getting libraries to work together, patchy Windows support, and a need for more debugging tools.


  • Curious Functor class. Ashley Yakeley described the curious class of functors for which foralls can move across.

  • Variadic functions and typeCast. Michael Shulman submitted a general version of the trick to implement variadic functions in Haskell outlined by Oleg

  • Serialising existential types. Misha Aizatulin pondered the interesting problem of serialisation of datatypes with existential constructors. Several options were suggested.

  • Replacing GMP. Peter Tanski updated the page relating to portably replacing GMP in GHC (and other Haskell systems)

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Clifford Beshers : "When we code in Haskell, we go home on time"
  • Bulat : "There is new Time library, which is supposed to replace old System.Time. We hope that it will happen before 2038"
  • edwardk : "I should probably just type up the problem specification in Haskell and click compile. Funny how that seems to yield the answer"
  • vincenz : "OCaml used to be pretty, Haskell made it ugly"
  • glguy : "I remember what class I was in when I was reading Hudak's book and discovered `fix'. Life altering..."
  • glguy : "> take 10 $ map length $ fix (([()]:).scanl (++) [()])"
  • lambdabot :"[1,1,2,3,5,8,13,21,34,55]"
  • agentzh : "Haskell is really a powerful weapon"
  • gaal : "You know you've been reading lots of Haskell papers when... someone says '(bbiab, $job)' and you try mentally to run :t on that"
  • audreyt : "Pugs seems to be just my excuse to apply each and every technique from the GHC changelogs..."
  • Pseudonym : "[OlegFacts] Oleg solves N P-hard problems in N log N time... in the type system"
  • dons : "[On improving Cabal dependency handling] fps 0.8 is an exemplary instance of part number fps 0.8. Interestingly, this one is lavender. Also, it is broken: it is (a fps 0.8 missing a base 1.0)."
  • Mark Bessey : "When really massively-parallel systems start to become more common, the programming model will have to change. What languages you'll likely use to program these beasts is an interesting question - most likely, it'll be a functional language, something like Haskell, or Erlang."
  • Philippa : "[vincenz] Forget theory, it's about pragmatics [Philippa] we're talking FP, they tend to be the same thing"

Contributing to HWN

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au . The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: September 18, 2006

Submitted by dons on Mon, 09/18/2006 - 3:07am.

Welcome to issue 41 of HWN, a weekly newsletter covering developments in the Haskell community. Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

The 2006 Haskell Workshop was held today in Portland, Oregon. Thanks to Edward Kmett for a report on the event.


  • Haskell98 Termination Analyser . Stephan Swidersk announced the integration of an automatic Haskell98 termination analyzer in the termination tool AProVE. The tool accepts full Haskell as specified in the Haskell 98 Report and is available through our web interface. More

  • Free theorems . Janis Voigtlaender announced that Sascha Boehme has done a project to implement the Reynolds/Wadler algorithm generating theorems from polymorphic types, plus simplifications and postprocessings for such free theorems. More info

  • Haddock/GHC SoC . David Waern announced a short status report of the "Port Haddock to use GHC" Summer of Code project. The GHC modifications, are finished and will be included in the GHC head repository soon.

  • AutoForms release 0.2 . Mads Lindstrøm released AutoForms 0.2, a library to ease the creation of GUIs. It does this by using generic programming (SYB) to construct GUI components. More info

  • HSPClientside 0.2 . Joel Björnson announced a new version of HSPClientside (0.2) ,developed as a GSoC project during this summer. HSPClientside is a Haskell Server Pages library for generatingJavaScript code. More info

  • SOE implementation based on Gtk2Hs . Duncan Coutts Due to popular demand the new SOE implementation based on Gtk2Hs is now available. The rendering quality is better than the original HGL version. Here's a side-by-side comparison

  • The experimental GHCi debugger . Pepe announced the results of his SoC project, the experimental Haskell debugger. More details

  • SmallCheck . Colin Runciman released a prototype tool that is similar in spirit, and in some of its workings, to QuickCheck. SmallCheck is, though, based on exhaustive testing in a bounded space of test values. More info

  • Frisby: composable, linear time parser for arbitrary PEG grammers . John Meacham released Frisby, an implementation of the 'packrat' parsing algorithm, which parse PEG grammars and have a number of very useful qualities, they are a generalization of regexes in a sense that can parse everything in LL(k), LR(k), and more, including things that require unlimited lookahead, all in guaranteed linear time. More information

  • HaskellNet . Jun Mukai published a status report on the state of his SoC project, HaskellNet

  • GHC's new support engineer . Simon Marlow announced that GHC now has a full-time support engineer, Ian Lynagh (aka Igloo on IRC). He'll be helping with all aspects of GHC, especially release management, bug diagnosis and tracking, documentation, packaging, and supporting other GHC hackers. Welcome Ian!


This section covers the Haskell' standardisation process.


  • The Haskell Workshop . Here is a summary of the talks presented today at the Haskell Workshop

  • RepLib: A Library for Derivable Type Classes . Stephanie Weirich presented a neat library for generic traversals. It covered just about everything you'd need and seemed pretty painless to use. From the abstract:

    Some type class instances can be automatically derived from the structure of types. As a result, the Haskell language includes the "deriving" mechanism to automatic generates such instances for a small number of built-in type classes. In this paper, we present RepLib, a GHC library that enables a similar mechanism for arbitrary type classes.

  • A Generic Recursion Toolbox for Haskell (Or: Scrap Your Boilerplate Systematically) . Deling Ren and Martin Erwig talked about another generics library, with a neat core "mother traversal" that abstracted over different data structure traversals.

    The Recursion Library for Haskell provides a rich set of generic traversal strategies to facilitate the flexible specification of generic term traversals. The underlying mechanism is the Scrap Your Boilerplate (SYB) approach. Most of the strategies that are used to implement recursion operators are taken from Stratego.

  • Strong Types for Relational Databases . Alexandra Silva and Joost Visser presented a relational database Using the type system to encode not only the types of fields it was joining, but a bit more about their meaning and role in the key.

    Type-level programming is used to maintain the consistency between header and rows, and between functional dependencies and tables. Type-level predicates are provided to check whether tables and functional dependencies arein particular normal-forms, or not.

  • Polymorphic Variants in Haskell . Koji Kagawa presented a paper on polymorphic variants in Haskell, describing some interesting type system extensions.

    In languages that support polymorphic variants, a single variant value can be passed to many contexts that accept different sets of constructors. Polymorphic variants are potentially useful for application domains such as interpreters, graphical user interface (GUI) libraries and database interfaces, where the number of necessary constructors cannot be determined in advance.

  • Extended Static Checking for Haskell . Dana Xu gave a great talk on ESC/Haskell, proving the partial correctness of programs with compile time checks for pre/postcondition violations, and using an external theorem prover to prove bits about arithmetic expressions. Very practical stuff. The extended static checking is beautiful in that it opens up a whole new arena in Haskell for machine checkable documentation.

  • Running the Manual: An Approach to High-Assurance Microkernel Development . Philip Derrin, Kevin Elphinstone, Gerwin Klein, David Cock and Manuel M.T. Chakravarty presented a microkernel paper. This was really good. Before I saw the talk I really questioned the judgement of prototyping a microkernel in Haskell. Now I want to go prototype one myself.

    We propose a development methodology for designing and prototyping high assurance microkernels, and describe our application of it. The methodology is based on rapid prototyping and iterative refinement of the microkernel in a functional programming language.

  • Strongly Typed Memory Areas -- Programming Systems-Level Data Structures in a Functional Language . Iavor S. Diatchki and Mark P. Jones gave a presentation on how you could extend the type system to include an extra kind for physical memory regions and data representations in memory, with endianness, and the like. He implemented it in a kind of strict pseudo-Haskell, but the general notation was pretty clean and would be usable for system level programming in Haskell.

  • User-Level Transactional Programming in Haskell . Peter Thiemann wrote on generalizing the interfacefor STM to other kinds of database and user-interface transactions, where he gave up the ability to automatically retry blocking on a changeset of TVars, producing a kind of transaction that could actually fail and be manually retried.

  • An Extensible Dynamically-Typed Hierarchy of Exceptions . Simon Marlow presented an extensible exception hierarchy using type classes.

    In this paper we address the lack of extensibility of the exception type in Haskell. We propose a lightweight solution involving the use of existential types and the Typeable class only, and show how our solution allows a fully extensible hierarchy of exception types to be declared, in which a single overloaded catch operator can be used to catch either specific exception types, or exceptions belonging to any subclass in the hierarchy.

  • Demo: Introducing the Haskell Equational Reasoning Assistant . Andy Gill came in and did a really neat, high energy, demo of an interactive equational reasoning/code refactoring tool. He actually loaded up the application and showed it refactoring live.

  • GenI: Natural Language Generation in Haskell . Eric Kow covered genI and gave a user's level overview of the features in Haskell that are useful in real code. The natural language generation stuff there was pretty nifty.

  • Demo: Typed Linear Algebra . Frederik Eaton covered a linear algebra library with ATLAS and LAPACK bindings in Haskell that uses type level enumerable values to provide its bounds. Neat stuff.

  • Demo: Interactive Debugging . David Himmelstrup unforutnately was unable to present his talk, due to illness. From the abstract:

    Haskell's lazy nature is a large part of its beauty. Unfortunately, laziness complicates debugging in the "stop, examine, continue" sense, and hence tools such as Freja, Hat and Hood have risen. This paper describes the implementation of a "stop, examine, continue" debugger for Glasgow Haskell

  • Demo: Haskell Program Coverage tool, HPC . A demo was presented on how you can use HPC to interactively control QuickCheck, get it to run some cases, and check to see how much coverage you have had, then have it run more cases if thats not enough. The notion of looking at the difference in the coverage sets between a good run and a bad run to try to isolate bugs seemsreally useful.

  • Demo: On computable types . Oleg Kiselyov presented a "proof by example" that the Haskell type system is Turing complete, with a 5 line type system lambda calculus and a 6 line type level fibonacci.

  • Haskell' Status Report -- An Update on the Next Haskell Standard . Isaac Jones Isaac gave a talk on the state of Haskell'

Quotes of the Week

  • Baughn : "I think I'm beginning to understand this language. I just defined: let 1 + 1 = 3"
  • SamB : "Haskell is the only language I know with first-class support for imperative programming"
  • David Amos : "The real reason for using Haskell is that the code comes out shorter, and is quicker to write, than in imperative languages .. What that means is, I can get much more done when I use Haskell"
  • SyntaxNinja : "I recommend seeing if people have a major problem, then pouring concrete on them, and implementing what you want anyway"
  • SamB : "I was just saying that encasing poeple in concrete is not the best solution to that problem"
  • Sean Russell : "[On the wmii window manager mailing list] Hah! That's a laugh. Since when does 'it compiles' equate to 'it will run (correctly)'? We're talking about C, after all... not Haskell."
  • Adaptec : "[In documentation for one of their chipsets] We have a disclaimer because there may be corner cases"
  • audreyt : "Yes, I'm aware that I'm abusing GHC beyond its designed purpose"
  • cjeris : "I have a little perl script that aliases gcc -freduced-suckage to ghc"
  • dibblego : "Using logic in imperative programming language channels is generally considered trolling"
  • edwardk : "lambdabot is the first irc bot I ever added to my buddy list"
  • gmh33 : "Haskell makes so much more sense now and all I did was figure out the typing thing"
  • musasabi : "reallyUnsafePointerEq# seems unsafe"
  • sieni : "The advantage of Haskell is that it doesn't suck"
  • therp : "Good morning. I think I have been dreaming of shift/reset continuations"

Contributing to HWN

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au . The darcs repository is available at
darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: August 14, 2006

Submitted by dons on Mon, 08/14/2006 - 1:10am.
Welcome to issue 40 of HWN, a weekly newsletter covering developments in the Haskell community. Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

A mega super bumper issue, for the 1st birthday of the Haskell Weekly News


  • The Haskell Workshop . Andres Loeh announced the preliminary schedule of the Haskell Workshop 2006, part of the 2006 International Conference on Functional Programming (ICFP)

  • dbus haskell bindings . Evan Martin announced preliminary D-Bus Haskell bindings. D-Bus is a message bus system, a simple way for applications to talk to one another. More

  • The GHC typechecker is Turing-complete . Robert Dockins was able to show how that the GHC typechecker with multi-parameter typeclasses, functional dependencies, and undecidable instances is Turing-complete.

  • Haskell Program Coverage . Colin Runciman announced the first release of hpc, a new tool for Haskell developers. Hpc records and displays Haskell program coverage. It provides coverage information of two kinds: source coverage and boolean-control coverage. More here

  • Smash your boiler-plate without class and Typeable . Oleg Kiselyov described a new generic programming technique, expressive enough to traverse a term and return another term of a different type, determined by the original term's type/structure. More details

  • Paper: Software Extension and Integration with Type Classes . Ralf Laemmel and Klaus Ostermann invite comments towards the final version of their paper Software Extension and Integration with Type Classes

  • HSP.Clientside 0.01 . Joel Björnson announced a release of his Summer of Code project HSP.Clientside 0.01. Present features include an embedding of (typed) JavaScript language in Haskell, a small combinator library for generating JavaScript code, and high-level interface to Ajax functionality.

  • Monadic probabilistic functional programing . Stefan Karrmann announced that he had extended Martin Erwig's PFP library to support abstract monads, cabal and darcs

  • hdbc-odbc . John Goerzen released DBC-odbc, the ODBC backend driver for HDBC, version

  • Few Digits 0.5.0 . Russell O'Connor This year, Few Digits competed in the More Digits contest. To celebrate, version 0.5.0 of Few Digits is available. Few Digits 0.5.0 is now ten times faster and three times more complicated. Few Digits has been Cabalized for your convenience. More info

  • System.FilePath 0.9 . Neil Mitchell announced System.FilePath 0.9

  • The History of Haskell . Phil Wadler, John Hughes, Paul Hudak and Simon Peyton Jones have been writing a paper, The History of Haskell, for the History Of Programming Languages conference (HOPL'07), and they invite feedback. Wiki page here.

  • AngloHaskell . Lemmih mentioned that AngloHaskell will be held at Cambridge in August. The agenda includes beer, unicycles, hacking and other fun. More info

  • Haskell XML Toolbox Version 6.0, 6.1 . Uwe Schmidt announced two new versions of the Haskell XML Toolbox. New features include ghc 6.4.2 support, better XPath integration, separate documentation for filter API and an arrow API

  • Down the rabbit hole . Bulat Ziganshin announced the availability of a new tutorial directed toward comprehensive explanation of the IO monad, and it's use in complex programs

  • ldap-haskell, arch2darcs and darcs-buildpackage . John Goerzen posted new versions of these packages

  • Internships on GHC and Haskell at MSR Cambridge . Simon Peyton-Jones announced that MSR Cambridge is taking interns year-round, not just in the summer months. GHC HQ are keen to attract motivated and well-qualified folk to work on improving or developing GHC. More details

  • FGL . Martin Erwig announced a new release of his well known Functional Graph Library (FGL).

  • Takusen . Alistair Bayley and Oleg Kiselyov released a new version of Takusen, a library for accessing DBMSs. The most significant code change is a new internal design, giving better separation of concerns like statement preparation, binding, and result-set processing. Takusen is now held in darcs, and hosted at haskell.org

  • Text.Regex.Lazy 0.44, 0.56, 0.66 and 0.70 . Chris Kuklewicz announced Text.Regex.Lazy 0.44-0.70, with many enhancements. Multiple backends are supported, in addition to the "full lazy" and the DFA backends. Text.Regex.Lazy is a replacement and enhancement for Text.Regex. More details here

  • Streams 0.2.1 beta . Bulat Ziganshin released Streams 0.2.1 beta, featuring various bug fixes and improvements to the streams library


This section covers the Haskell' standardisation process.


  • Package "mounting" . Sven Hallberg proposed drop the assumption that Haskell modules are closed entities, and rather always consider them to be seen in the context of a particular package.

  • Cabal and DLLs . Jason Dagit described how he was able to use Cabal with Visual Haskell to build Dlls in Windows.

  • Replacing GMP . Peter Tanski sparked a long discussion on the merits and difficulties of replacing the GMP numerical library used by GHC and nhc98 with a library using a less restrictive license. More here, here and here

  • The cost of Integer . Serge Mechveliani asked about the runtime cost of Integer, triggering an interesting discussion

  • Thread-local variables . Frederik Eaton started a large discussion on the merits or otherwise of thread-local variables.

  • Type level programming made simple . Oleg Kiselyov composed a useful comparison between Prolog and type level programming in Haskell

  • IRC channel statistics . Don Stewart created some graphs and analysis of activity and growth of the #haskell IRC channel

Quotes of the Week

  • Dan Piponi : "Writing introductions to monads seems to have developed into an industry"
  • John Meacham : "I liken learning Haskell to tipping over a vending machine. You can't just push it, you gotta rock it back and forth a few times building up momentum until bam! suddenly the flash of insight hits and it all makes sense."
  • Andrew Bromage : "What was considered 100 milli-Olegs of type hackery five years ago is standard operating procedure th ese days"
  • Tim Toady : "Learning Haskell itself is easy -- I've done it several times already"
  • Adam : "Lisp is like Ruby with an ugly syntax, impossible stdlib, and macros that don't compensate for above shortcomings"
  • Lennart A : "Hbc still has some unique features, like views. That I've never used.."
  • Edward K : "I've been playing with type level 2s complement arithmetic"
  • Edwin B : "I think I'd panic if I had to write something that wasn't a compiler"
  • Ozone : "Our C++ guru at work is getting a bit sick of me saying: Ah, so that's like in Haskell, but not quite as elegant..."
  • roconnor : "Life lesson from today: 1 closure is nice, 500 000 closures sucks"
  • scsibug : "I could have sworn it was incorrect until it type-checked"
  • stepcut : "I wrote 1 + 1 in php once, and got 11 -- wasn't quite what I was hoping for"

Contributing to HWN

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au . The darcs repository is available at
darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: July 03, 2006

Submitted by dons on Sun, 07/02/2006 - 9:12pm.
Welcome to issue 39 of HWN, a weekly newsletter covering developments in the Haskell community. Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

A week of busy activity in the community. Thanks to Simon Marlow and Josef Svenningsson for contributions to this issue.


  • HDBC 1.0 . John Goerzen released the latest HDBC. HDBC is a database tool, modeled loosely on Perl's DBI interface, though it has also been influenced by Python's DB-API v2, JDBC in Java, and HSQL in Haskell. You can find the code here.

  • hpodder . John Goerzen announced the first release of hpodder. hpodder is a podcast downloader (podcatcher) written in pure Haskell. It exists because John was unsatisfied with the other podcatchers for Linux. Full details here.

  • hmp3 1.1 . Don Stewart announced a new release of hmp3, the curses-based mp3 player written in Haskell. Release 1.1 is a maintenance release, fixing support for GHC 6.4.2

  • HSP.Clientside 0.001 . Joel Bjornson announced a prerelease version of Hsp.Clientside. This is Joel's Summer of Code project aiming to add support for client-side script generation in Haskell Server Pages. The basic building blocks for embedding Javascript has been implemented. As the project proceeds a suitable programming model based on these components will be added. Hopefully this will also include some kind of higher level Ajax support. For more information see here.

  • QDBM and Hyper Estraier bindings . Jun Mukai released a library of bindings to Quick DBM, a database module similar to GDBM, Berkeley-DB, optimized for performance and a simple API. Additionally, Jun's code includes support for Hyper Estraier, a full-text search system using QDBM, with the ability to search documents according to keywords.

  • Streams 0.2 . Bulat Ziganshin announced the beta release of his Streams 0.2 library, providing fast string and binary IO, now with Data.ByteString support.

  • HNOP 0.1 . Ashley Yakeley released the first version of HNOP 0.1. HNOP does nothing. This version should be considered "beta" quality.

  • HList updates . Oleg Kiselyov announced that HList, the library for strongly typed heterogeneous lists, records, type-indexed products (TIP) and co-products is now accessible via darcs, here. Additionally, Oleg pointed to some new features for HList, including a new representation for open records. Finally, he published a note on how HList supports, natively, polymorphic variants: extensible recursive open sum datatypes, quite similar to Polymorphic variants of OCaml. HList thus solves the `expression problem' -- the ability to add new variants to a datatype without changing the existing code.

  • Haskell IO Inside . Bulat Ziganshin wrote a new introductory tutorial to IO in Haskell, Down the Rabbit's Hole.

  • Bytecode API 0.2 . Robert Dockins published the Yhc Bytecode API version 0.2. More details here.

  • Translating Haskell into English . Shannon Behrens published a new Haskell tutorial, hoping to give readers a glimpse of the Zen of Haskell, without requiring that they already be Haskell converts.


This section covers the Haskell' standardisation process.


  • Haskell and the Great Language Shootout, reloaded . Simon Marlow highlighted some remarks and discussion from Brent Fulgham, the driving force behind the Great Language Shootout on the impact recent advances in the performance of GHC have had. In particular, many benchmarks had to be rewritten due to the performance advantage lazy Haskell programs had over strict (and wasteful) entries in other languages. Brent noted that "applications written in Haskell can be reasonably expected to yield good performance on all of the common x86 platforms without customizations". This in turn led to a discussion about further improvements we can expect to see in GHC Haskell over the next few months.

  • HNOP, doing nothing, and really complex ways of doing nothing . Ashley Yakeley forked a somewhat surreal thread regarding Haskell programs that do nothing.

Quotes of the Week

  • Brian Hulley : "It is definitely *a* haskell. There is actually no word in English with a silent 'h', though this statement is unfortunately controversial and news to whoever wrote the spell checker used in many printed publications. Of course some particular dialects use different pronunciation like 'me 'otel room 'ad an 'askell 'mpiler in t' closet as well as tub 'n sink tha knows'"

Code Watch

    Thu Jun 29 06:58:36 PDT 2006  Simon Marlow
        * No longer force -fvia-C for the RTS, it can now be compiled with the

    Sat Jul  1 01:43:45 PDT 2006  Don Stewart
        * Import Data.ByteString.Lazy, improve ByteString Fusion, and resync
        with FPS head

           This patch imports the Data.ByteString.Lazy module, and its helpers,
           providing a ByteString implemented as a lazy list of strict
           cache-sized chunks. This type allows the usual lazy operations to be
           written on bytestrings, including lazy IO, with much improved space
           and time over the [Char] equivalents.

Contributing to HWN

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au . The darcs repository is available at
darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: June 25, 2006

Submitted by dons on Sun, 06/25/2006 - 12:29am.

Welcome to issue 38 of HWN, a weekly newsletter covering developments in the Haskell community. Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

This edition mechanised, automated and published thanks to Text.PrettyPrint, hopefully making it easier to keep the weekly news schedule in future.


  • The GHC Hackathon . Simon Peyton-Jones announced that GHC HQ are going to run a hackathon, in Portland, just before ICFP this September (14-15th). It'll be held at Galois's offices, in Beaverton. Thanks go to Galois for hosting the meeting. Here are the details. If you are interested in finding out a bit about how GHC works inside, then you should find the hackathon fun. It will be informal and interactive. If you think you might come, please take a look at the above page, and register.

  • Bytecode API library . Robert Dockins announced a release of an alpha version of a library for reading and writing the YHC bytecode file format. It reads and writes the entire bytecode set, version 1.9 (the one used by recent YHC builds). Check it out.


This section covers the Haskell' standardisation process.


  • Extensible records using associated types . Barney Hilken suggested an interesting encoding of polymorphic extensible records using associated types.

  • Graphing community activity . Don Stewart posted started graphing the commit activity of various Haskell community projects over time.

Contributing to HWN

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au . The darcs repository is available at
darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: June 16, 2006

Submitted by dons on Fri, 06/16/2006 - 1:52am.

Welcome to issue 37 of HWN, a weekly newsletter covering developments in the Haskell community. Each Monday, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

This edition -- better late than never -- covers another madly busy 2 weeks for the Haskell community.


  • Google Summer of Code. The Haskell.org team announced that nine Haskell projects have been selected to receive funding to the value of $45k under Google's 2006 Summer of Code program. A wide range of projects will be worked on, contributing to the community important tools and libraries. The students have until August 21 to complete their projects, and receive their grants. Details of the accepted projects can be found here

  • Haskell Communities & Activities Report. Andres Loeh published the 10th edition of the Haskell Communities and Activities Report (HCAR). If you haven't encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects and individuals working on, with, or inspired by Haskell.

    Read the 10th edition here.

  • Would you like a job working on GHC?. Simon Peyton-Jones announced that GHC HQ is looking for support engineer. The Glasgow Haskell Compiler (GHC) is now being used by so many people, on so many platforms, that GHC HQ has been struggling to keep up. In particular, the candidate should be someone who is enthusiastic about Haskell, and fired up about the prospect of becoming a GHC expert.

  • Shellac and Lambda Shell 0.3. Robert Dockins announced the simultaneous release of Shellac 0.3 and Lambda Shell 0.3. Shellac is a library for creating read-eval-print style shells. It makes binding to feature-rich shell packages (ie, readline) easier. Lambda shell is full-featured shell environment for evaluating terms of the pure untyped lambda calculus and a showcase/tutorial for Shellac's features.

  • darcs-graph. Don Stewart released darcs-graph, a tool for generating graphs of commit activity for darcs repositories.

  • VersionTool 1.0. Manuel Chakravarty announced version 1.0 of VersionTool, a small utility that:

    • extracts version information from Cabal files,
    • maintains version tags in darcs,
    • computes patch levels by querying darcs,
    • extracts the current context from darcs, and
    • adds all this information to a source file

  • Streams 0.1e. Bulat Ziganshin released Streams library version 0.1e. Now cabalised and BSD-ified.

  • Hitchhikers guide to Haskell - chapter 5. Dmitry Astapov announced that chapter 5 of his online tutorial, the Hitchhikers guide to Haskell, is available. Changes include: It's bigger. It's better. It now comes with source code included.

  • Haskell Shell (HSH) 0.1.0. John Goerzen released version 0.1.0 of HSH, the Haskell shell. Things are still very preliminary in many ways, but this version already lets you:

    • Run commands
    • Pipe things between commands
    • Pipe command input/output into and out of pure Haskell functions
    • Pure Haskell functions are as much a first-class citizen as is grep or cat

  • Edison 1.2. Robert Dockins released the final, stable release of Edison 1.2. Edison is a library of efficient, purely-functional data structures for Haskell.

  • Arrays & References Library 0.1. Bulat Ziganshin announced version 0.1of his arrays and references library. Featuring:

    • Unboxed references in IO and ST
    • Monad-independent interfaces to boxed and unboxed references
    • Syntax sugar to make using of mutable objects easier (=:, +=, -=,..)
    and more.

  • Kamiariduki Shelarcy released Kamiariduki - a system to judge your derivative work's purpose and license is valid with Ceative Commons License Works.

  • lambdabot 4.0. Don Stewart announced the release of version 4.0 of the venerable Haskell IRC bot, lambdabot. lambdabot is a stable, feature rich IRC bot based on a plugin framework. lambdabot 4.0 comes with a suite of more than 50 plugins, and many new features.


This section covers activity on Haskell' standardisation process.


  • A road for Haskell into OS kernels. Oleg Kisleyov sparked a bit of a discussion about Haskell's use in OS projects, after similar remarks from Andrew Tanenbaum at USENIX.

Contributing to HWN

You can help us create new editions of this newsletter. Please see the contributing information, send stories to dons -at- cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: May 22, 2006

Submitted by dons on Sun, 05/21/2006 - 10:05pm.

Welcome to issue 36 of HWN, a weekly newsletter covering developments in the Haskell community. Each Monday, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

Another busy and exciting week for the Haskell community.


  • Hugs 2006. Ross Paterson announced a new major release of Hugs, including an installer for Windows and a new WinHugs interface. It is available from the Hugs page.

  • Linspire Chooses Haskell for Core OS Development. Clifford Beshers announced that the OS team at Linspire, Inc. is standardizing on Haskell as their preferred language for core OS development. Much of the infrastructure is being written in Haskell, including the Debian package builder (aka autobuilder). Other tools such as ISO builders, package dependency checkers are in progress. The goal is to make a tight, simple set of tools that will let developers contribute to Freespire, based on Debian tools whenever possible.

  • lambdaFeed. Manuel Chakravarty released lambdaFeed -- lambdas for all! lambdaFeed is an RSS 2.0 feed generator. It reads news items - in a non-XML, human-friendly format - distributed over multiple channels and renders them into the RSS 2.0 XML format understood by most news aggregators as well as into HTML for inclusion into web pages. Source is available in darcs. Check it out.

  • Milfoh, an image to texture loading library. Maurizio Monge announced he has put together a very small library, using SDL_image (and a bare minimun of SDL), to load image files as opengl textures. More information here.

  • Haskell Charting Library. Tim Docker released his Haskell 2D charting library. It's still at quite an early stage, but already it has:

    • Line charts, points charts, fills, and combinations.
    • Automatic layout sizing and adjustment.
    • Auto scaling of axis ranges
    • Extensible to support new plot types
    • Uses the cairo graphics library for output
    and more. Further information and a darcs repo.

  • Edison 1.2RC4. Robert Dockins announced the 4th release candidate for Edison 1.2. Edison is a library of efficient data structures for Haskell.

  • Collections pre-release. Jean-Philippe Bernardy announced an alpha release of the new collections package he (and others) have been working on. It's still far from perfect, but I hope it's already a good choice for many use cases of collection data structures.

  • Haskell Graph Automorphism Library. In a busy week, Jean-Philippe also released HGAL 1.2 (Haskell Graph Automorphism Library), a Haskell implementation of Brendan McKay's algorithm for graph canonic labeling and automorphism group. (aka Nauty). Improvements over the previous release include a faster algorithm implementation and the library is now cabalised.

  • Darcs 1.0.7. Tommy Pettersson announced the release of darcs 1.0.7, containing a few bug fixes, and some new features.


This section covers activity on Haskell' standardisation process.


  • GHC Hackathon. Simon Peyton-Jones posted more information on the proposed GHC Hackathon, in Portland, later this year prior to ICFP. The idea is that to give an extended tutorial about GHC's glorious innards. Then have some hacking time in which you can pick something which you think GHC could do better, and implement it, with the two Simons wandering causing trouble. If you're interested, then complete the small survey indicating your preferences.

  • QuickCheck Fun with Phantom Types. Dominic Steinitz posted on an interesting puzzle involving phantom types and quickcheck, and pondered how to generate random types as well as random values in those types.

  • Gigabytes and terabytes in Haskell. Don Stewart made some measurements (here, here, and here) of the new lazy bytestring extension to Data.ByteString, showing performance often within a few percent of C for gigabyte and terabyte data sizes.

Contributing to HWN

You can help us create new editions of this newsletter. Please see the contributing information, send stories to dons -at- cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: May 8, 2006

Submitted by dons on Sun, 05/07/2006 - 10:43pm.

Welcome to issue 35 of HWN, a weekly newsletter covering developments in the Haskell community. Each Monday, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.


  • hmake. Malcolm Wallace released version 3.11 of hmake, the compiler-independent project-building tool for Haskell programs. It automates recompilation analysis, based on import declarations in your files, to rebuild only those modules that are impacted by a change. It is rather like ghc's --make mode, but faster, less memory intensive, and it works with any compiler (e.g. hbc, nhc98).

  • cpphs. In a busy week, Malcolm also released version 1.2 of cpphs, the in-Haskell implementation of the C pre-processor. The major change in this release is that the source files have been re-arranged into a cabal-ised hierarchical library namespace, so you can use cpp functionality from within your own code, in addition to the stand-alone utility.

  • Cabal 1.1. Duncan Coutts (as the new Cabal release manager) announced that Cabal-1.1.4, the version shipped with GHC 6.4.2 is now available to download as a separate tarball. There is also a new mailing list for Cabal development discussion including patch review. This is also where patches sent via "darcs send" will end up. The Cabal team would also like to take the opportunity to invite people to get involved in Cabal development, either new features or squashing annoying bugs.

  • DownNova-0.1. Lemmih released downNova, a program designed for automating the process of downloading TV series from mininova.org. Written in Haskell, it will scan your downloaded files to find out what your interests are and download missing/new episodes to your collection. Advanced classification techniques are used to interpret the file names and 'downNova' will correctly extract series name, season number, episode number and episode title in nigh all cases.

  • Student SoC Application Deadline is rapidly approaching. Paolo Martini encouraged students to apply to google, using the student application form, and Haskell.org is looking forward to the several dozen applications we hope to receive.


This section covers activity on Haskell' standardisation process.


  • Speed of Binary serialisation. Bulat Ziganshin posted a comparison of Handle and Bulat's Streams IO performance, with interesting results to ponder.

  • GHCi-based 'eval' and the ML top level. Geoff Washburn sparked a bit of a thread when wondering how to emulate the ML "top level" in Haskell. Some alternatives were proposed, including ghc-api and hs-plugins.

Quote of the Week

  • Lemmih :: Haskell is the best glue language I know. It's like super-glue.

Code Watch

  • Wed Apr 26 11:21:14 PDT 2006 simonpj
    (ghc): Arrange that -fth is no longer implied by -fglasgow-exts

    Messages involving Template Haskell are deeply puzzling if you don't know about TH, so it seems better to make -fth an explicit flag. It is no longer switched on by -fglasgow-exts.

  • Fri Apr 28 06:07:18 PDT 2006 Don Stewart
    (packages/base): Import Data.ByteString from fps 0.5.

    Fast, packed byte vectors, providing a better PackedString.

  • Wed May 3 04:33:06 PDT 2006 Simon Marlow
    (packages/base): Improve performance of Integer->String conversion

    See http://www.haskell.o rg//pipermail/libraries/2006-April/005227.html
    Submitted by Bertram Felgenhauer

Contributing to HWN

You can help us create new editions of this newsletter. Please see the contributing information, send stories to dons -at- cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: May 1, 2006

Submitted by dons on Sun, 04/30/2006 - 11:06pm.

Welcome to issue 34 of HWN, a weekly newsletter covering developments in the Haskell community. Each Monday, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

A double-plus episode this week, as last week's HWN went missing during a furious hack fest.


  • GHC 6.4.2. Simon Marlow announced the release of the Glasgow Haskell Compiler, version 6.4.2. 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 (C, whatever). GHC is distributed under a BSD-style open source license.

    For more information, see:

  • Communities and Activities Report. Andres Loeh released the call for contributions to the 10th (!) Haskell Communities and Activities Report. If you are working on any project that is in some way related to Haskell, write a short entry and submit it to Andres.

    The Haskell Communities and Activities Report is a bi-annual overview of the state of Haskell as well as Haskell-related projects over the last, and possibly the upcoming 6 months. If you have only recently been exposed to Haskell, it might be a good idea to browse the November 2005 edition -- you will find interesting topics described as well as several starting points and links that may provide answers to many questions.

  • Haskell' Status Report. Isaac Jones released a Haskell' status report. Currently the committee is focused on two issues, standardising concurrency and extensions to the class system.

  • Google Summer of Code. Paolo Martini announced that Haskell.org would have a presence as an official mentoring organisation for this year's Google Summer of Code. Several members of the Haskell community have volunteered as mentors, and a large number of proposals have been listed. If you're interested in mentoring, suggesting projects, or applying as a student to spend your summer writing Haskell code, check it out!

  • 2006 GHC Hackathon. Simon Marlow writes that the GHC team is considering the possibility of organising a GHC Hackathon around ICFP this year. Tentative details are on the wiki page.

  • Data.ByteString. Don Stewart announced new versions of FPS/Data.ByteString, the fast, packed strings library for Haskell.

  • Debian from Scratch. John Goerzen announced Debian From Scratch (DFS), a single, full rescue linux CD capable of working with all major filesystems, LVM, software RAID, and even compiling a new kernel. The tool that generates the ISO images (dfsbuild) is written in Haskell. The generated ISO images also contain full, working GHC and Hugs environments.

  • Hazakura - search-based MUA. Jun Mukai announced the first release of hazakura, a search-based mail client, written in Haskell.

  • (HS)XML queries. Oleg Kiselyov published a note demonstrating Scrap your boilerplate 3 style generic term processing for transformations and selections from (HS)XML-like documents.


This section covers activity on Haskell' standardisation process.


  • Global IORefs. Brian Hulley forked a long running thread on the use of top level mutable variables in an application he's developing, leading to many contributions on how to rewrite the code in a functional style.

  • cabal-get. Isaac Jones released a note discussing some changes to Cabal, including integration of the cabal-get tool into the main branch.

  • Fast serialisation. Bulat Ziganshin published some result of a test of various serialization libraries speed, comparing his AltBinary code against the standard Binary implementations, with very encouraging results.

  • Gigabyte strings. Don Stewart posted the results of some experiments into using gigabyte strings (as ByteStrings) in GHC, with good results.

Darcs corner

  • Darcs patcher. Nicholas FitzRoy-Dale announced Darcs patcher, a tool to take a darcs patch file in the and applies it to the source tree in your current working directory. It was written as a tool to keep Bazaar repositories in sync with Darcs, with the Darcs repo being the master. Nicholas writes that he finds darcs much easier to use and less prone to failure.

Contributing to HWN

You can help us create new editions of this newsletter. Please see the contributing information, send stories to dons -at- cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: April 17, 2006

Submitted by dons on Sun, 04/16/2006 - 11:18pm.

Greetings, and thanks for reading issue 33 of HWN, a weekly newsletter covering developments in the Haskell community. Each Monday, new editions are posted to the Haskell mailing list and to The Haskell Sequence. RSS is also available. Headlines also go to haskell.org.


  • Halfs, a Haskell filesystem. Isaac Jones announced the first release of Halfs, a filesystem written in Haskell. Halfs can be mounted and used like any other Linux filesystem, or used as a library. Halfs is a fork (and a port) of the filesystem developed by Galois Connections. In addition, Halfs comes with a virtual machine to make using it extremely easy. You don't need an extra partition or a thumb drive, or even Linux (Windows and Mac OS can emulate the virtual machine). See more at the Halfs site.

  • DrIFT-2.2.0. John Meacham released DrIFT-2.2.0, the type sensitive preprocessor for Haskell. It extracts type declarations and directives from modules. The directives cause rules to be fired on the parsed type declarations, generating new code which is then appended to the bottom of the input file. Read more here.

  • MissingH 0.14.2. John Goerzen announced version 0.14.2 of MissingH, the library of "missing" Haskell code. Now including support for shell globs, POSIX-style wildcards and more. Check here for more details.

  • HAppS - Haskell Application Server 0.8 Einar Karttunen announced HAppS 0.8. The Haskell Application Server version 0.8 contains a complete rewrite of the ACID and HTTP functionalities. Features include:

    • MACID - Monadic framework for ACID transactions.
    • An HTTP Server (outperforms Apache/PHP in informal benchmarks).
    • An SMTP Server.
    • Mail delivery agent.
    • DNS resolver in pure Haskell
    • XML and XSLT. Separate application logic from presentation using XML/XSLT.
    • And more..
    More information on the the HAppS page.

  • Index-aware linear algebra. Frederik Eaton announced an index-aware linear algebra library written in Haskell. The library exposes index types and ranges so that static guarantees can be made about the library operations (e.g. an attempt to add two incompatibly sized matrices is a static error). Frederik's motivation is that a good linear algebra library which embeds knowledge of the mathematical structures in the type system, such that misuse is a static error, could mean Haskell makes valuable contribution in the area of technical computing, currently dominated by interpreted, weakly typed languages.

  • Crypto-3.0.3. Dominic Steinitz announced Crypto-3.0.3, a new version of the Haskell Cryptography Library. Version 3.0.3 supports: DES, Blowfish, AES, Cipher Block Chaining (CBC), PKCS#5 and nulls padding, SHA-1, MD5 , RSA, OAEP-based encryption (Bellare-Rogaway), PKCS#1v1.5 signature scheme, ASN.1, PKCS#8, X.509 Identity Certificates, X.509 Attribute Certificates. See here for more.


This section covers activity on Haskell' standardisation process.


  • QuickCheck. Koen Claessen hinted that a "brand new" version of QuickCheck with lots of cool features is soon to be released.

  • Accurate event scheduling. Henning Thielemann asked about how to improve the accuracy of event scheduling, while working on Haskore, the Haskell music system. John Meacham suggested a binding to the Linux real time clock interface, while Tomasz Zielonka pointed to a library he has been developing using software transactional memory actions for accurate timeouts. He also mentioned the new registerDelay function in the GHC head. Measurements indicated that the average error from the expected waiting time dropped from 0.010140108245s to 0.00080999391s. Quite good results.

  • Good fusion. A casual remar k about an alternative version of the inits function lead to a huge discussion about using fusion to improve code quality.

Code watch

  • Sun Apr 2 14:59:11 PDT 2006 simonpj
    Improve newtype deriving

    Ross Paterson pointed out a useful generalisation of GHC's newtype-deriving mechanism. This implements it. The idea is to allow newtype Wrap m a = Wrap (m a) deriving (Monad, Eq) where the representation type doesn't start with a type constructor.

  • Tue Apr 11 05:04:41 PDT 2006 simonpj
    Allow IO to be wrapped in a newtype in foreign import/export

    Up to now, the silent unwrapping of newtypes in foreign import/export has been limited to data values. But it's useful for the IO monad itself:

            newtype MyIO a = MIO (IO a)
            foreign import foo :: Int -> MyIO Int
    This patch allows the IO monad to be wrapped too.

Contributing to HWN

You can help us create new editions of this newsletter. Please see the contributing information, send stories to dons -at- cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn