General News

Haskell Weekly News: October 03, 2006

Submitted by dons on Tue, 10/03/2006 - 2:04am.

Welcome to issue 43 of HWN, a weekly newsletter covering developments in the Haskell community.

The proceedings of the first Haskell Workshop are now available online, and work has begun on a unified library for generics in Haskell.


  • Proceedings Haskell Workshop 1995. Henrik Nilsson announced that in celebration of the 10th Haskell Workshop that took place recently, the proceedings of the very first Haskell workshop, in La Jolla 1995, have now been made available on the Haskell Workshop home page. Thanks to Paul Hudak for help locating the proceedings and arranging for them to be scanned into PDF.

  • Common library for generic programming. Johan Jeuring and Andres Loeh announced an initiative to design a common library for generic programming, which should work together with most of the Haskell compilers, and for which they hope to guarantee support for generics in Haskell into the future. If you want to get involved (or just want to see the discussion), you can subscribe to the generics mailing list. Check the Haskell research wiki for some background on generics.

  • GHC 6.6 Second Release Candidate. Ian Lynagh announced that the Second Release Candidate phase for GHC 6.6 is underway. Get testing!

  • Lazy functional language for the JVM. Luke Evans announced that the research group at Business Objects has developed a lazily evaluated, strongly-typed language called CAL, with many similarities to Haskell, targeting the JVM, to facilitate representing certain kinds of business logic as reusable, composable pieces.


This section covers the Haskell' standardisation process.


  • Typeclass versus Prolog programming. Oleg Kiselyov wrote further on the connection between typeclass hacking and logic programming.

  • Irrefutable patterns for existential types. Several Haskellers discussed, in a long thread, issues relating to irrefutable patterns when combined with existentials or GADTs. Read more.

  • GHC on the Mac. Simon Peyton-Jones sought contributors to help maintain GHC on the Mac.

  • Smallest Double. Tamas Papp initiated a thread regarding finding the smallest Double such that 1+x /= x, for a numerics problem.

  • Migrating content to the new wiki. Ian Lynagh forced an action to finally close down the old hawiki, and move all content to the new haskell wiki. Work to be done is here.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Bill Wood: It became obvious that when a Prolog program is tuned by removing non-determinism it moves towards a functional program.
  • Bjarne Stroustrup: Any verbose and tedious solution is error-prone because programmers get bored. [S 9.4 of C++, 2nd edition]
  • Hamilton Richards: It's fair to say that functional programming requires a very different mind-set, but once you've mad e the `jump`, programming in conventional languages feels like doing arithmetic in Roman numerals.
  • Larry Wall: Take Lisp, you know it's the most beautiful language in the world -- at least up until Haskell came along.
  • dons: Welcome to computer science, we count from 0.
  • glguy: This is like Web 5GL. I like it!
  • sjanssen: Quoth the Prelude, Chapter 6, verse 4: Yeah verily shall repeat floweth cons cells over.

Code Watch

  • Fri Sep 29 09:07:17 PDT 2006 simonpj. Remove Linear Implicit Parameters, and all their works. Linear implicit parameters have been in GHC quite a while, but we decided they were a mis-feature and scheduled them for removal. This patch does the job.

About the Haskell Weekly News

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

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at The darcs repository is available at darcs get

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

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 . The darcs repository is available at darcs get

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

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 . The darcs repository is available at
darcs get

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

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

  • 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 . The darcs repository is available at
darcs get

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

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 . The darcs repository is available at
darcs get

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

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 . The darcs repository is available at
darcs get

Progress Report of HaskellNet

Submitted by jmuk on Sat, 06/17/2006 - 9:10pm.

At first, the repository of HaskellNet is moved to Please refer to it after this.

I imported HTTP modules into haskellnet. As I mentioned, the importing have a problem. It has no patch data of HTTP because I just copied the files into my directory and did darcs add.

Next, I modified the implementation of SMTP and POP3 to depend on the Network.Stream and Network.TCP which seem to be very useful abstractions of socket.
# However, it should become a part of Streams or SSC...? I don't know the best solution by now.

Because the MissingH is LGPL and HAppS is GPL, I cannot import these libraries into HaskellNet directly. Now I discuss with the developers of these libs, and I will distribute other version of HaskellNet such like `HaskellNet.LGPL' which includes current my implementation and other LGPL network libraries.

And then, IMAP implementation have little progress. I wrote a sort of parser for the server response.

BTW, there is a problem to build haskellnet. Because it has same modules of HTTP, ghc is confused at the system which already is installed HTTP. Therefore, I must have removed the HTTP before building haskellnet, which annoys me...
Can I change the module name to HaskellNet from Network? Or, other better solutions?

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

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


  • Google Summer of Code. The 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- The darcs repository is available at darcs get

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

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- The darcs repository is available at darcs get

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


  • 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 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 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- The darcs repository is available at darcs get