[Haskell] Haskell Weekly News: September 18, 2006

Donald Bruce Stewart dons at cse.unsw.edu.au
Mon Sep 18 05:06:32 EDT 2006

Haskell Weekly News
Issue 41 - September 18, 2006

   Welcome to issue 41 of HWN, a weekly newsletter covering developments
   in the Haskell community. Each week, new editions are posted to [1]the
   Haskell mailing list as well as to [2]the Haskell Sequence and
   [3]Planet Haskell. [4]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.

   1. http://www.haskell.org/mailman/listinfo/haskell
   2. http://sequence.complete.org/
   3. http://planet.haskell.org/
   4. http://sequence.complete.org/node/feed
   5. http://haskell.org/


     * Haskell98 Termination Analyser . Stephan Swidersk [6]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. [7]More

   6. http://article.gmane.org/gmane.comp.lang.haskell.general/14193
   7. http://aprove.informatik.rwth-aachen.de/

     * Free theorems . Janis Voigtlaender [8]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. [9]More info

   8. http://article.gmane.org/gmane.comp.lang.haskell.general/14160
   9. http://haskell.as9x.info/

     * Haddock/GHC SoC . David Waern [10]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.

  10. http://article.gmane.org/gmane.comp.lang.haskell.general/14149

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

  11. http://article.gmane.org/gmane.comp.lang.haskell.general/14148
  12. http://autoforms.sourceforge.net/

     * HSPClientside 0.2 . Joel Björnson [13]announced a new version of
       HSPClientside (0.2) ,developed as a GSoC project during this
       summer. HSPClientside is a Haskell Server Pages library for
       generating JavaScript code. [14]More info

  13. http://article.gmane.org/gmane.comp.lang.haskell.general/14133
  14. http://darcs.haskell.org/SoC/hsp.clientside/

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

  15. http://article.gmane.org/gmane.comp.lang.haskell.general/14132
  16. file://localhost/home/dons/dons/src/hwn/now
  17. http://haskell.org/~duncan/gtk2hs/SOE-cairo.png

     * The experimental GHCi debugger . Pepe [18]announced the results of
       his SoC project, the experimental Haskell debugger. [19]More

  18. http://article.gmane.org/gmane.comp.lang.haskell.general/14131
  19. http://haskell.org/haskellwiki/GHC/GHCiDebugger

     * SmallCheck . Colin Runciman [20]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. [21]More info

  20. http://article.gmane.org/gmane.comp.lang.haskell.general/14129
  21. http://www.cs.york.ac.uk/fp/smallcheck0.0.tar

     * Frisby: composable, linear time parser for arbitrary PEG grammers
       . John Meacham [22]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. [23]More information

  22. http://article.gmane.org/gmane.comp.lang.haskell.general/14128
  23. http://repetae.net/computer/frisby/

     * HaskellNet . Jun Mukai [24]published a status report on the state
       of his SoC project, HaskellNet

  24. http://article.gmane.org/gmane.comp.lang.haskell.general/14126

     * GHC's new support engineer . Simon Marlow [25]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!

  25. http://article.gmane.org/gmane.comp.lang.haskell.general/14125


   This section covers the [26]Haskell' standardisation process.

     * [27]Writing / status teams - call for volunteers
     * [28]do and if then else
     * [29]map and fmap
     * [30]All monads are functors

  26. http://hackage.haskell.org/trac/haskell-prime
  27. http://article.gmane.org/gmane.comp.lang.haskell.prime/1657
  28. http://article.gmane.org/gmane.comp.lang.haskell.prime/1599
  29. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1625/focus=1625
  30. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1590/focus=1590


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
       [31]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.

  31. http://www.cis.upenn.edu/~sweirich/RepLib/

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

         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.

  32. http://web.engr.oregonstate.edu/~erwig/reclib/

     * Strong Types for Relational Databases . Alexandra Silva and Joost
       Visser [33]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 are in particular normal-forms, or not.

  33. http://lmf.di.uminho.pt/wiki/pub/PURe/CoddFish/StrongTypesForRDBs-draft-04-03-2006.pdf

     * Polymorphic Variants in Haskell . Koji Kagawa [34]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.

  34. http://guppy.eng.kagawa-u.ac.jp/~kagawa/PVH

     * Extended Static Checking for Haskell . Dana Xu [35]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.

  35. http://www.cl.cam.ac.uk/~nx200/

     * Running the Manual: An Approach to High-Assurance Microkernel
       Development . Philip Derrin, Kevin Elphinstone, Gerwin Klein,
       David Cock and Manuel M.T. Chakravarty [36]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.

  36. http://www.cse.unsw.edu.au/~chak/papers/DEKC+06.html

     * Strongly Typed Memory Areas -- Programming Systems-Level Data
       Structures in a Functional Language . Iavor S. Diatchki and Mark
       P. Jones [37]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.

  37. http://www.cse.ogi.edu/~diatchki/papers/haskell007-diatchki.pdf

     * User-Level Transactional Programming in Haskell . Peter Thiemann
       wrote on generalizing the interface for 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 [38]presented an extensible exception hierarchy using type

         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.

  38. http://www.haskell.org/~simonmar/papers/ext-exceptions.pdf

     * 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
       [39]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.

  39. http://hal.inria.fr/docs/00/08/87/87/PDF/haskell01-kow.pdf

     * 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

     * Demo: Interactive Debugging . David Himmelstrup unforutnately was
       unable to present [40]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

  40. http://darcs.haskell.org/~lemmih/hw2006.ps

     * Demo: The Galois 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 seems
       really useful.

     * Demo: On computable types . Oleg Kiselyov [41]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

  41. http://www.haskell.org/pipermail/haskell/2006-September/018486.html

     * Haskell' Status Report -- An Update on the Next Haskell Standard .
       Isaac Jones Isaac gave a talk on the state of [42]Haskell'

  42. http://hackage.haskell.org/trac/haskell-prime

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

     * 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

     * 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

     * 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

     * 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

Contributing to HWN

   To help create new editions of this newsletter, please see the
   [43]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

  43. http://haskell.org/haskellwiki/HWN

More information about the Haskell mailing list