A philosophical difference between Haskell and Lisp

Common Lisp:

    (subseq
     (remove-if
      (complement #'numberp)
      (butlast list 3))
     0 5)

In above Common Lisp code, we use four different functions which do one task:

    * subseq sequence start &optional end => subsequence
    * remove-if test sequence => result-sequence
    * complement function => complement-function
    * butlast list &optional n => result-list

> This is known as composability, or the UNIX philosophy. In Lisp a procedure tends to accept many options which configure its behaviour.

Check out the UNIX man for tail, grep, ... to see how strange above quote about 'unix philosophy is'. In reality Unix commands are programs with obscene amount of configuration options, piping data as text or bytes around...

Generally I'm a big fan of the descriptive code which one writes by using keyword options to Lisp functions. I think it beats Haskell code for readability by a mile, since the intent is much clearer in the source code.

Ignoring "What exactly does'Lisp' mean?"

The comparison to Common Lisp ignores its past {faulkner_quote}. Common Lisp has roots in the days before including a standard library was common practice. In part this is simply a design decision. In part it is the fact that compiling "remove-if-not" to binary implementation of the compiler/interpreter saved compile time; disk space; and facilitates REPL development. It also probably made distribution simpler in the pre/proto internet days when decisions were made.

By the time Common Lisp was standardized, it had many years of deployment in the field on commercial projects. The standard reflects use. Haskell's standard reflects a closer connection to Computer Science than to working programmers, e.g. threads are not part of the Haskell language standard, they're an extension incorporated by the ubiquitous Glascow Haskell Compiler [1]. ANSI Common Lisp rolled up similar extensions from a diversity of commercial and open compilers into the standard. It's an industry consensus document that results from commercial success. By contrast GHC maintainers are perhaps "benevolent oligarchs for life": a person who is offended by the impurity is free to "write their own Haskell compiler and make it popular.

[1]: https://downloads.haskell.org/~ghc/7.0.4/docs/html/users_gui...