Free haskell software for linux

RSA-Haskell is a collection of command-line cryptography tools and a cryptography library written in Haskell. The project is intended to be useful to anyone who wants to secure files or communications or who wants to incorporate cryptography in their Haskell application.
The libraries include Haskell implementations of SHA1, EME-OAEP, EMSA-PSS, MGF, RSAES-OAEP, and RSA-PSS. These standards implement signature/verification, strong cryptography, and hashing.
Enhancements:
- Documentation is now available for the command line utilities.
- An easy-to-use Windows binary release is available.

ConfigFile for Haskell is a configuration file parser and writer library for Haskell.
The ConfigFile module works with configuration files in a standard format that is easy for the user to edit, easy for the programmer to work with, yet remains powerful and flexible. It is inspired by, and compatible with, Pythons ConfigParser module. It uses files that resemble Windows .INI-style files, but with numerous improvements.
ConfigFile provides simple calls to both read and write config files. Its possible to make a config file parsable by this module, the Unix shell, and make.
Enhancements:
- This package was formerly part of MissingH and is being split off as part of the MissingH transition plan.

Haskell Database Connectivity project provides an abstraction layer between Haskell programs and SQL relational databases. This lets you write database code once, in Haskell, and have it work with any number of backend SQL databases (MySQL, Oracle, PostgreSQL, ODBC-compliant databases, etc.)
HDBC is modeled loosely on Perls DBI interface http://search.cpan.org/~timb/DBI/DBI.pm, though it has also been influenced by Pythons DB-API v2, JDBC in Java, and HSQL in Haskell.
HDBC is a from-scratch effort. It is not a reimplementation of HSQL, though its purpose is the same.
Main features:
- Ability to use replacable parameters to let one query be executed multiple times (eliminates the need for an escape function)
- Ability to access returned rows by column number
- Ability to read data from the SQL server on-demand rather than reading the entire result set up front
- HUnit testsuite for each backend driver
- Well-defined standard API and easy backend driver implementation
- Lazy reading of the entire result set (think hGetContents, but for the results of SELECT) (see sFetchAllRows)
- Support for translation between Haskell and SQL types
- Support for querying database server properties
- Add-on package (hdbc-missingh) to integrate with MissingH, providing a database backend for AnyDBM.
- Support for querying metadata such as column names.
- Support for querying additional metadata (column types, etc.)

HaXml is a collection of utilities for parsing, transforming, filtering and generating XML documents using Haskell. Its basic facilities include:
- a parser for XML,
- a separate error-correcting parser for HTML,
- an XML validator,
- pretty-printers for XML and HTML.
For processing XML documents, the following components are provided:
Combinators is a combinator library for generic XML document processing, including transformation, editing, and generation.
Haskell2Xml is a replacement class for Haskells Show/Read classes: it allows you to read and write ordinary Haskell data as XML documents. The DrIFT tool (available from http://repetae.net/~john/computer/haskell/DrIFT/) can automatically derive this class for you.
DtdToHaskell is a tool for translating any valid XML DTD into equivalent Haskell types.
In conjunction with the Xml2Haskell class framework, this allows you to generate, edit, and transform documents as normal typed values in programs, and to read and write them as human-readable XML documents.
Finally, Xtract is a grep-like tool for XML documents, loosely based on the XPath and XQL query languages. It can be used either from the command-line, or within your own code as part of the library.
Enhancements:
- Add features/limitations/changes here

hslogger is a logging framework for Haskell, roughly similar to Pythons logging module. The project lets each log message have a priority and source be associated with it.
The programmer can then define global handlers that route or filter messages based on the priority and source. hslogger also has a syslog handler built in.
Main features:
- Each log message has a priority and a source associated with it
- Multiple log writers can be on the system
- Configurable global actions based on priority and source
- Extensible log writers (handlers)
- Default handlers that write to the console, file handles, or syslog
- Easy to use operation

cpphs is a liberalised re-implementation of cpp, the C pre-processor, in Haskell.
Why re-implement cpp? Rightly or wrongly, the C pre-processor is widely used in Haskell source code. It enables conditional compilation for different compilers, different versions of the same compiler, and different OS platforms.
It is also occasionally used for its macro language, which can enable certain forms of platform-specific detail-filling, such as the tedious boilerplate generation of instance definitions and FFI declarations. However, there are two problems with cpp, aside from the obvious aesthetic ones:
- For some Haskell systems, notably Hugs on Windows, a true cpp is not available by default. * Even for the other Haskell systems, the common cpp provided by the gcc 3.x series is changing subtly in ways that are incompatible with Haskells syntax. There have always been problems with, for instance, string gaps, and prime characters in identifiers. These problems are only going to get worse.
So, it seemed right to provide an alternative to cpp, both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers.
This version of the C pre-processor is pretty-much feature-complete, and compatible with the -traditional style. It has two main modes:
- conditional compilation only (--nomacro),
- and full macro-expansion (default).
In --nomacro mode, cpphs performs only conditional compilation actions, namely #includes, #ifs, and #ifdefs are processed according to text-replacement definitions (both command-line and internal), but no parameterised macro expansion is performed. In full compatibility mode (the default), textual replacements and macro expansions are also processed in the remaining body of non-cpp text.
Working features:
#ifdef simple conditional compilation
#if the full boolean language of defined(), &&, ||, ==, etc.
#elif chained conditionals
#define in-line definitions (text replacements and macros)
#undef in-line revocation of definitions
#include file inclusion
#line line number directives
line continuations within all # directives
/**/ token catenation within a macro definition
## ANSI-style token catenation
# ANSI-style token stringisation
__FILE__ special text replacement for DIY error messages
__LINE__ special text replacement for DIY error messages
__DATE__ special text replacement
__TIME__ special text replacement
Macro expansion is recursive. Redefinition of a macro name does not generate a warning. Macros can be defined on the command-line with -D just like textual replacements. Macro names are permitted to be Haskell identifiers e.g. with the prime and backtick ` characters, which is slightly looser than in C, but they still may not include operator symbols.
Numbering of lines in the output is preserved so that any later processor can give meaningful error messages. When a file is #included, cpphs inserts #line directives for the same reason. Numbering should be correct even in the presence of line continuations. If you dont want #line directives in the final output, use the --noline option.
Any syntax errors in cpp directives gives a message to stderr and halts the program. Failure to find a #included file produces a warning to stderr, but processing continues.
Differences from cpp:
In general, cpphs is based on the -traditional behaviour, not ANSI C, and has the following main differences from the standard cpp.
General
- The # that introduces any cpp directive must be in the first column of a line (whereas ANSI permits whitespace before the #).
- Generates the #line n "filename" syntax, not the # n "filename" variant.
- C comments are only removed from within cpp directives. They are not stripped from other text. Consider for instance that in Haskell, all of the following are valid operator symbols: /* */ */* However, you can turn on C-comment removal with the --strip option.
- Macros are never expanded within Haskell comments, strings, or character constants, unless you give the --text option to disable lexing the input as Haskell.
- Macros are always expanded recursively, unlike ANSI, which detects and prevents self-recursion. For instance, #define foo x:foo expands foo once only to x:foo in ANSI, but in cpphs it becomes an infinite list x:x:x:x:..., i.e. cpphs does not terminate.
Macro definition language
- Accepts /**/ for token-pasting in a macro definition. However, /* */ (with any text between the open/close comment) inserts whitespace.
- The ANSI ## token-pasting operator is available with the --hashes flag. This is to avoid misinterpreting any valid Haskell operator of the same name.
- Replaces a macro formal parameter with the actual, even inside a string (double or single quoted). This is -traditional behaviour, not supported in ANSI.
- Recognises the # stringisation operator in a macro definition only if you use the --hashes option. (It is an ANSI addition, only needed because quoted stringisation (above) is prohibited by ANSI.)
- Preserves whitespace within a textual replacement definition exactly (modulo newlines), but leading and trailing space is eliminated.
- Preserves whitespace within a macro definition (and trailing it) exactly (modulo newlines), but leading space is eliminated.
- Preserves whitespace within macro call arguments exactly (including newlines), but leading and trailing space is eliminated.
- With the --layout option, line continuations in a textual replacement or macro definition are preserved as line-breaks in the macro call. (Useful for layout-sensitive code in Haskell.)
Enhancements:
- This release now includes a compatibility script for command line arguments to match the original cpp.
- There are several minor bugfixes, e.g. quotes around replacements for special macros like __FILE__, etc.
- Interaction with preprocessors like hsc2hs is also improved: if they allow non-cpp directives like #def, these are now passed through to the output with a warning to stderr, rather than halting with an error.
- Likewise, a #! line in a shell script is now ignored.

ftphs is an FTP client and server library for Haskell. ftphs is easy to use, fully supports text and binary transfers, can optionally support lazy operations, and is standards-compliant.
The ftphs server can serve up either real or virtual filesystem trees.
Main features:
- Easy to use operation
- Full support of text and binary transfers
- Optional lazy interaction
- Server can serve up a real or a virtual filesystem tree
- Standards compliant