I have made a github project for a package of Emacs modules for extending Haskell mode. Some initial modules so far:

1. haskell-align-imports.el
2. haskell-installed-packages.el
3. haskell-navigate-imports.el
4. haskell-sort-imports.el
5. inf-haskell-send-cmd.el

I have more in progress and more planned.

One example is making editing imports automatically alphabetically ordered and indented. This one is a little tricky to get right so I will get back to you on this one. Once I am happy with it, I will generalize it to a lot of Haskell statements, like data declarations:

data Foo = X
         | Y

If I type bar after Foo, I should get,

data Foobar = X
            | Y

automatically. I have seen this type of thing in the Yi editor and it is a really good idea. Equally for definitions:

foo x = do x
           y

If I add another parameter, the rest of the function body should be indented accordingly,

foo x y = do x
             y

and so on.

I wrote a self-contained Emacs module for retrieving all the installed Haskell package descriptions (as an association list), and the exposed modules inside them.

• Haskell installed packages

This is intended for Elisp programmers to use to make import handling and package handling easier.

For example, if I run (haskell-installed-packages), I get:

("Cabal-1.8.0.2" "array-0.3.0.0" "base-3.0.3.2" "base-4.2.0.0"
"bin-package-db-0.0.0.0" "bytestring-0.9.1.5"
"containers-0.3.0.0" "directory-1.0.1.0" "extensi\
ble-exceptions-0.1.1.1" "ffi-1.0" "filepath-1.1.0.3"
"ghc-6.12.1" ...)

I can also run the following:

(haskell-read-pkg-description 
  (haskell-ghc-pkg-command "describe Cabal-1.8.0.2"))

And the following is returned:

(("name" . "Cabal") ("version" . "1.8.0.2") ("id"
. "Cabal-1.8.0.2-bc92fe595a99db06fca8c2eb712108b4")
("license" . "BSD3") ("copyright" . "2003-2006, Isaac Jones
2005-2009, Duncan Coutts") ("maintainer"
. "cabal-devel@haskell.org") ("stability:" . "") ("homepage"
. "http://www.haskell.org/cabal/") ("package-url:" . "")
("description" . "The Haskell Common Architecture for
Building Applications and Libraries: a framework defining a
common interface for authors to more easily build their
Haskell applications in a portable way. . The Haskell Cabal
is part of a larger infrastructure for distributing,
organizing, and cataloging Haskell libraries and tools.")
("category" . "Distribution") ("author" . "Isaac Jones
<ijones@syntaxpolice.org> Duncan Coutts
<duncan@haskell.org>") ...)

Finally I acquire a complete list of all modules installed with (haskell-installed-modules), which is defined in terms of the above two functions.

("Distribution.Compiler" "Distribution.InstalledPackageInfo"
"Distribution.License" "Distribution.Make"
"Distribution.ModuleName" "Distribution.Package"
"Distribution.PackageDescription"
"Distribution.PackageDescription.Configuration"
"Distribution.PackageDescription.Parse"
"Distribution.PackageDescription.Check" "Distribution.ParseUtils"
"Distribution.ReadE" ...)

These functions cache automatically. You can force them to refresh the cache by passing t to them. Or run the following function.

In your .emacs start-up file, put:

(haskell-installed-packages-refresh-all)

Which will refresh all packages and modules. It takes about 3 seconds on my machine. But I am okay with that because I restart Emacs rarely. You do not have to put it here, but it saves waiting for it to update when you are mid-way through some action.

In the future it is completely possible to speed this up by checking the last modified date on the Haskell package databases, and to only update the changed packages.

For my use case, I am going to use it for smex or anything.el-like completion and write another module with clever import insertion so that one can navigate between import statement parts with arrow keys. What can I say?; I really do not like typing out import statements.

For Emacs newbies, if you are impatient and want to use this right away, pop this in your .emacs file:

(require 'haskell-installed-packages)
(setq haskell-ghc-pkg-bin-path "/home/chris/Programs/bin/ghc-pkg")
(haskell-installed-packages-refresh-all)

You can omit the setq line if it works without it; otherwise change it to wherever your ghc-pkg binary lies. Now a very simple shortcut for completing Haskell modules:

(defun haskell-complete-module ()
  "Insert a completed Haskell module."
  (interactive)
  (insert (ido-completing-read "Module: "
                               (haskell-installed-modules))))

Then bind it to a key:

(define-key haskell-mode-map (kbd "C-c i") 'haskell-complete-module)

Or whatever you prefer.

I wrote a self-contained Emacs module for navigating to and from the import list in Haskell files.

• Haskell modules navigator

The use case is, for example, two sets of module lists:

import           Control.Applicative                   ((<$>))
import           Data.Bool.Higher                      (bool)
import           Data.List                             (sort,intercalate)
import           Data.Maybe                            (catMaybes)
import           System.Process                        (readProcess)
import           System.Environment                    (getArgs)

import qualified Distribution.PackageDescription.Parse as P
import qualified Distribution.PackageDescription       as PD
import qualified Distribution.ModuleName               as PM
import           Text.Regex.Posix                      ((=~))

And I am half way down the file, and realise I need to import Control.Concurrent. So I hit F8, which takes the cursor to the Control.Applicative line. I enter my import statement, and then hit C-u F8 to return back to the middle of the file to what I was doing.

I made a little Elisp script which aligns your import lists in your Haskell code. I pasted it to Gist:

• Haskell align imports for Emacs
• Haskell align imports for Vim

mauke from the Freenode IRC contributed an equivalent vim plugin.

I found two good Haskell libraries recently and realised they were not packaged up and put on Hackage! So I updated them to the latest base and GHC extensions, made a proper Cabal package out of them and uploaded them:

• frisby: Linear time composable parser for PEG grammars.
• pappy: Packrat parsing; linear-time parsers for grammars in TDPL.

If you have interest in being the maintainer of these packages, please let me know.

Lots of people had not even heard of these two packages above before I uploaded them to Hackage. So I am gonna go out on a limb and say packaging up substantial code bases and putting them on Hackage should be standard practice in the Haskell community.

I was pondering how naming Haskell packages with a proper hierarchy is quite important, and wondered what the general hierarchy of the Hackage packages was like. So I grabbed the tarball of pakage descriptions from Hackage and ran a little messy Haskell script and got this list.

Here is a snippet:

hsdns:          ADNS
hsdns:          ADNS.Base
hsdns:          ADNS.Endian
hsdns:          ADNS.Resolver
cv-combinators: AI.CV.ImageProcessors
HOpenCV:        AI.CV.OpenCV.CV
HOpenCV:        AI.CV.OpenCV.CxCore
HOpenCV:        AI.CV.OpenCV.HighGui

It is interesting to see how there are quite a few packages that could be easily put into the proper namesace, e.g ADNS below should be in the Network hierarchy. It is also cool to see clusters of separate packages providing functionality for the same module, e.g check out Control.Applicative!

special-functors:                 Control.Applicative
base:                             Control.Applicative
applicative-extras:               Control.Applicative.Backwards
applicative-extras:               Control.Applicative.Compose
applicative-extras:               Control.Applicative.Error
InfixApplicative:                 Control.Applicative.Infix
category-extras:                  Control.Applicative.Parameterized
action-permutations:              Control.Applicative.Permutation
applicative-extras:               Control.Applicative.State
yjtools:                          Control.Applicative.Tools
unicode-symbols:                  Control.Applicative.Unicode
base-unicode-symbols:             Control.Applicative.Unicode

Control.Concurrent also has a lot going on inside it. There are quite a lot of packages under Network, too.

One idea: Hackage could have an additional page which displays this, fully linked up to the packages in question, with an MSDN-style complete collapsible/expandable module hierarchy menu on the left and documentation on the right. I am not saying that is the right way to do it, but it certainly makes for fun browsing for the Haskell entire open source codebase. (It would also encourage library writers to put their libraries in a useful namespace.)

In the past month I moved to Italy for a new Haskell job. Hopefully, we will be releasing some open source contributions.

I added about 25 more steps to Try Haskell and touched on types in Haskell, clickable code samples, lessons selection, go-back support, stricter expression checking, from the help of feedback from YCombinator, including Simon Pratt, who provided various patches to the jquery console with refactoring, fixing the history and adding standard console shortcuts.

I tidied up the JSON service code, removed redundant files, tided up module imports, made the mueval-core path not hard coded, etc. It is currently written with the FastCGI API. I have started a branch with the aim of switching it to Snap.

I have also added top-level binding support, e.g.:

> x = 1
> (y,z) = (5,6)
> x * y * z
=> 30
>

It works mostly in the same way GHCi does, with nested LET expressions. I think this way is sound. The bindings are per-session; they expire when you close your browser.

There is one change to the JSON service, when evaluating a top-level expression, the success return value is:

{"bind":"OK."}

Failure is returned as normal, e.g.

{"error":"Not in scope: `y"}

Another neat thing I added as suggested by tumult on YCombinator is support to link to a given expression, e.g.:

> map (*2) [1..1 0]
=> [2,4,6,8,10,12,14,16,18,20]
> link
link for map (*2) [1..10]
>  

(The link for map (*2) [1..10] text is a link.)

I also re-enabled Raphael support for the hell of it.

I have more plans for it such as embedded code editor and smallcheck exercises, user-uploaded tutorials, and adding an embedded console to Hackage at some point would be nice, but that is all for now.

In other news, two other languages have started their own Try Lang sites! Check these out:

• Try Clojure
• Try Erlang

Raising awareness of all functional languages is a great thing!

The hpaste site used to join the #haskell IRC channel and sit there waiting for pastes. When someone made a paste it would announce them in the channel with a link. Half a year ago (or longer, I guess) hpaste was rewritten and hpaste2 was born. Unfortunately, the IRC announcer failed to work on the server it runs on.

It’s a pretty convenient feature and it encourages people to paste and share the code they’re having problems with and the code they find interesting and want to share. If hpaste sends the link for you, it’s not an active thing on your part.

I figured it would be a good idea to use the rss2irc program on Hackage, which, I believe, is what the Hackage IRC announcer uses. E.g.

* hackagebot hashed-storage 0.4.11 - Hashed file storage support code.                            
  http://hackage.haskell.org/package/hashed-storage-0.4.11 (EricKow)

I read the hpaste source and it has some code for generating an RSS feed but it’s all commented out. So I wrote a little program to periodically fetch the main page of hpaste and generate an RSS feed from it and write it to a file in my web server directory. I’ve been thinking of doing this for more than half a year, but thought someone’ll sort it out.. never did. So here we go.

I run it like this:

hpaste-feed /var/www/tryhaskell.org/hpaste.rss 30

And then just hook-up rss2irc with it:

rss2irc http://tryhaskell.org/hpaste.rss \
'hpaste@irc.freenode.net/#hpaste-test' \
-i 1 -l --author & disown

I make a paste, and within a couple seconds, tada!

<hpaste>  a test paste (chrisdone) http://hpaste.org/fastcgi/hpaste.fcgi/view?id=24822

I’m running it on the tryhaskell server so hopefully it should be stable 24/7. Only problem is hpaste.org going down, but can’t be avoided. I’ll need to see what errors are thrown with the Network.HTTP library when the request times out or fails.

EDIT: It appears cabal-install already supports bash completion for commands, provided by a script in the bash-completion directory of the cabal-install package. It also supports flag completion. Cool!

A couple other people at Zurihac agreed that it would be nice if Cabal (cabal-install) supported completion like git. You can write git co instead of git commit, etc. saving a bit of typing in the late hacking hours. I made a wee patch for Cabal 0.6.4 to do this. Here’s me building cabal-install with cabal-install.

chris@chrisamilo:~/Haskell/cabal-install-0.6.4$ cabal co;cabal b;cabal i
Resolving dependencies...
Configuring cabal-install-0.6.4...
Preprocessing executables for cabal-install-0.6.4...
Building cabal-install-0.6.4...
Resolving dependencies...
Configuring cabal-install-0.6.4...
Preprocessing executables for cabal-install-0.6.4...
Building cabal-install-0.6.4...
Installing executable(s) in /home/chris/.cabal/bin

It’s pretty nice. I guess it’s probably preferable to write some personal scripts to run on top of cabal but it’d be nice if everyone had it.

As with most Haskell projects the source code is really easy to patch so I’ll probably do more cabal-install hacking.

UPDATE: The service went down 5 April at about 19:50 GMT+1 to about 20:21. I had to update the watchdog to be more aggressive for Linode (as opposed to my development machine). Just letting you guys know.

$ git clone git://github.com/chrisdone/tryhaskell.git

$ git clone git://github.com/chrisdone/haskell-json.git

http://tryhaskell.org/haskell.json?method=eval&expr=23*52

{"result":"1196","type":"(Num t) => t","expr":"23*52"}

http://tryhaskell.org/haskell.json?method=load&contents=x=1

{"success":"wrote file."}

http://tryhaskell.org/haskell.json?method=eval&expr=x

{"result":"5","type":"Integer","expr":"x"}

http://tryhaskell.org/haskell.json?method=load&contents=x=1&guid=ch2

http://tryhaskell.org/haskell.json?method=eval&expr=Just%201&pad=doStuff

doStuff({"result":"Just 1","type":"(Num t) => Maybe t","expr":"Just 1"})

function jsonp(url,func) {
    handleJSON = function(r){
        script.remove();
        func(r);
    };
    var script = $('<script type="text/javascript" src="'+url+'"></script>');
    script.attr('src',url);
    $('body').append(script);
}

var handleJSON = function(a){ alert('Unassigned JSONP: ' + a); }

jsonp("http://tryhaskell.org/haskell.json?method=eval&pad=handleJSON&expr="
       + encodeHex("34*23"),
      function(resp){
         alert("Result: " + resp.result);
      });