Liskell

If

Haskell = Haskell semantics + Haskell syntax
then
Liskell = Haskell semantics + Lisp syntax
Actually we can add "Lisp-styled meta-programming" to the last equation.

Liskell Syntax

Liskell is Haskell on the inside but looks like Lisp on the outside, as in its source code it uses the typical Lisp syntax forms, namely symbol expressions, that are distinguished by their fully parenthesized prefix notation form. Liskell captures the most Haskell syntax forms in this prefix notation form. To give you an idea of how this works in practise, here is the typical functional programming Hello World example namely factorial (written without multi-line equations):

In Haskell
fact n = 
  if n == 0
    then 1
    else n * (fact (n - 1)))
In Liskell:
(define (fact n)
  (if (== n 0)
      1
      (* n (fact (- n 1)))))

Meta-Programming

Liskell features a different meta-programming facility than the one found in Haskell with Template Haskell. Before turning the stream of lexed tokens into an abstract Haskell syntax tree, Liskell adds an intermediate processing data structure: the parse tree. The parse tree is essentially is a string tree capturing the nesting of lists with their enclosed symbols stored as the string leaves. The programmer can implement arbitrary code expansion and transformation strategies before the parse tree is seen by the compilation stage.

After the meta-programming stage, Liskell turns the parse tree into a Haskell syntax tree before it sent to the compilation stage. Thereafter the compiler treats it as regular Haskell code and produces a Haskell calling convention compatible output. You can use Haskell libraries from Liskell code and vice versa.

Implementation

Liskell is implemented as an extension to GHC and its darcs branch is freely available from the project's website. The Liskell Prelude features a set of these parse tree transformations that enables traditional Lisp-styled meta-programming as with defmacro and backquoting. The project's website demonstrates meta-programming application such as proof-of-concept versions of embedding Prolog inference, a minimalistic Scheme compiler and type-inference in meta-programming.

Project status

The future development roadmap includes stabilization of its design, improving the user experience for daily programming -- especially error reporting -- and improving interaction with Emacs.