The Chosen Paradigms: A Comparative Analysis of Lisp and Haskell

Lispers and Haskellers often engage in debates about the merits of their respective languages. One such discussion involves the question: 'Do you think Lisp is jealous of Haskell?' In essence, the question is moot; both languages represent different programming paradigms and have their own unique strengths. I believe that Lisp and Haskell should complement each other rather than be envious of each other's features.

Addressing the Question of Envy

My response to the original question is straightforward: Envy is a futile emotion when it comes to programming languages. Instead of focusing on envious exchanges, it might be more constructive to explore what each language offers and what we miss from one when using the other. Here, I'll discuss some significant differences between the two and highlight key features I find missing from Lisp when programming in Haskell.

Key Missing Features in Common Lisp

When transitioning from Haskell to Common Lisp, I notice a few major differences. Here are the significant features I miss:

1. Type System

The type system in Haskell is incredibly powerful and expressive. In Haskell, you can define types with high accuracy using built-in polymorphism and recursive types. This allows the compiler to do extensive type inference and derivation, ensuring that the program is safer and more robust from a type standpoint. In contrast, Common Lisp's type system, while robust, lacks some of these expressive capabilities. Functions in Common Lisp often require explicit type declarations, and the compiler's ability to infer and work with types is more limited. Haskell's type system is so powerful that the compiler can almost guarantee the safety and correctness of the program from a type perspective.

2. Algebraic Data Types (ADTs)

Algebraic data types (ADTs) are a key feature in Haskell that I greatly miss in Common Lisp. ADTs are a concise and elegant way to define sum and product types. They allow for inductive definitions and pattern matching, making programs both short and easier to reason about. In Haskell, you can define a data type like a Maybe with just a few lines, whereas in Common Lisp, it requires more boilerplate code. This makes writing and maintaining code significantly easier and more readable.

In Common Lisp: (adt:defdata maybe just t nothing) This gives you the constructor functions just and nothing, which are already present in Haskell. While this is indeed an improvement over Common Lisp, it still falls short in terms of expressiveness and convenience.

For example, defining a Maybe type in Haskell would be:

data Maybe a Just a | Nothing

3. Laziness

Laziness is a significant advantage in Haskell, especially when it comes to constructing unbounded data structures. This feature allows you to express complex data structures and algorithms in a declarative and efficient manner. Consider the problem of generating all strings that satisfy a given context-free grammar. In Haskell, this can be elegantly solved using the Omega monad, which is not only concise but also composable.

In Common Lisp, the strict evaluation strategy complicates the implementation of lazy evaluation. While you can implement laziness manually, it often requires more boilerplate and explicit handling of computation. Here is a simplified implementation in Common Lisp:

(defun grammar-enum (grammar max-length) (labels ((generate (expr) (cond ((symbolp expr) (if (symbolp (symbol-value expr)) (grammar-enum (symbol-value expr) max-length) (list expr)) ((listp expr) (let ((result (list)) (alternatives (cdr expr)) (current-choices (generate (car expr)))) (dolist (alt alternatives) (push (mapcar (lambda (choice) (append choice (generate alt))) current-choices) result)) result)))) (when (and (symbolp expr) (symbol-value expr)) (grammar-enum expr max-length)) (cons expr (generate (car (cdr expr))))))) (generate grammar))

While this code works, it is much more verbose and less elegant compared to the Haskell version. The expressiveness of laziness in Haskell allows for a more declarative and concise solution, making it easier to focus on the problem rather than the intricacies of lazy computation.

Closing Thoughts

While Haskell and Common Lisp have different strengths, each is valuable in its own right. The type system, algebraic data types, and laziness in Haskell are features that are notably absent in Common Lisp but are highly desirable. Thankfully, libraries like cl-algebraic-data-type exist to help bridge some of these gaps, but they fall short of what Haskell offers natively.

Ultimately, rather than feeling envy for certain features, it is more productive to appreciate the unique strengths of each language and leverage them according to the specific needs of the project at hand.