HAIFA

What is HAIFA?

HAIFA is a Haskell implementation of the Web-Service architecture, characterised by interoperability in terms of web protocols, interfaces, messages and types. In order to achieve this goal we have extended the existing Haskell libraries with the following components;

• The XMLData type-class which allows annotated serialization of Haskell types with a built in schema for defining how an algebraic type should be serialized.
• A simple HTTP server, which allows handlers to be built in as Haskell functions.
• A service executor, which allows different methods of calling service operations to be defined. This is paired with the function soapCall, which uses an executor to produce a side-effecting function from the input message to the output message.
• The Service type-class, which allows instantiated Haskell function types to be built into HTTP handlers for integration into the HTTP server.
• XML Schema type-mapping, which translates W3C XML Schema types to Haskell types and uses the XMLData class to derive serializers.

It is our eventual plan that full service discovery support will be possible in the form of WSDL to Haskell module compiler. Arguably the most difficult part of this is XML Schema type mapping, and so once this is complete WSDL support should be relatively straight forward.

News

27/11/2006

Christian Maeder kindly created some patches to make HAIFA work with GHC 6.6. I've added the changes to the darcs repository. Sorry for lack of other progress, I'm busy with theory.

01/03/2006

I've added a link to the developmental http://abridgegame.org/darcsdarcs]] repository. See below.

13/02/2006

New release out, version 0.10. This fixes a number of bugs in HAIFA, particularly its incorrect use of both HXT (lack of entity resolution) and HTTP (using simpleHTTP which doesn't always work for none HTML payloads).

It also adds some basic support for XML Schema mapping in Text.XML.Schema.TypeMapper.FromHaskell which simply takes a list of types and a URI and maps to an XML Schema, e.g.

buildXSD myURI (undefined :: MyType1 .+. undefined :: MyType2 .+. HNil)

SOAP Array support (serialization) is back now in Org.Xmlsoap.Schemas.Encoding after I'd fixed the serializers. See the module for documentation (although hopefully I'll update the tutorial with more info soon). I've also turned off trace support as default in the serializer, although I think soapCall still traces.

Make sure you also grab the latest tarballs of HCl, SYB3 and HTTP as well.

06/02/2006

I've now pretty much come to the conclusion that it is, sadly, impossible to have type-class decidability in HAIFA if generics are to be retained. The problem is that gaining decidability requires that Data instances are given a fixed context, and then a type-class XMLDataData can be set up as a synonym for Data DictXMLData to avoid breaking the second instance decidability rule.

The problem with this is that a circular dependency exists : XMLData -> Data -> Sat -> XMLData ... This means that XMLData and Data instances must be declared in the same place. Apart from removing half the usefulness of type-classes this means that either both XMLData and Data must be derived by TH, or neither. This is very inconvenient, as Data is almost always derived automatically whereas XMLData frequently needs customization.

As a result I'm left with a choice, either I can effectively remove the usefulness of SYB by making it strongly dependent on XMLData, or I can put up with undecidability. I'm now happy to do the latter as I can justify it, although I reckon I can perhaps make modules which only contain XMLData instances decidable via a class synonym. SYB3 stays.

Incidently, I should be able to get a new release out within the next few days, once I've fixed all the bugs.

27/01/2006

I've managed to get some key parts of HAIFA working again and have eliminated some of the complexity by removing the XML hook system, as it is (despite what my paper says) essentially useless with the current Haskell type-system. I've redubbed this version of HAIFA as HAIFA-lite, as it is my hope that I can eliminate any reliance on undecidable instances by removing dependence on SYB3 (and thus any genericity). At the moment, this is not the case and SYB3 is still needed.

I'm releasing a pre-release version (0.9) of HAIFA-lite which I'm not guaranteeing works (although it seems to). It's just there as HAIFA has been vapour-ware for too long, considering the amount of source-code that exists. I've also uploaded my modified versions of SYB3 and the Haskell HTTP library which it depends on.

This release includes Network.Service, the XML Serializer stack and the XML Schema data-types, which can be used for serializing and deserializing schemas. A Haskell type-mapping library should also follow soon.

Download

Version 0.10 (13/02/2006)

Version 0.9 (27/01/2006)

Developmental Darcs Repository

Dependencies

Haskell XML Toolbox

HCl

Modified versions of

SYB3 - thanks to Ralf Laemmel (see http://homepages.cwi.nl/~ralf/syb3/)

Haskell HTTP

Further Reading

HAIFA: An XML Based Interoperability Solution for Haskell (dvi, ps, pdf)
Simon Foster
6th Symposium on Trends in Functional Programming (TFP 2005) pp. 103-118

Implementing Web-Services with the HAIFA Framework (pdf)
Simon Foster
The Monad.Reader Issue 1

Quick Tutorial

License

HAIFA is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See COPYING for more info.

Updated November 27, 2006