Some say it is, some say it isn't. Lemme see... (this applies mainly to CommonLisp; SchemeLanguage has a stronger functional tradition).
It is a little silly to say it isn't, because lisp was the original functional language. Otoh, it is pretty easy to see that some lisp variants are not particularly functional today.
- More to the point, much of the CommonLisp community these days isn't terribly interested in the functional aspects of the language. Many aspects of CL, such as CommonLispObjectSystem and the whole MetaObjectProtocol, are rather non-functional. This has causes some FunctionalWeenies (sorry) to suggest that Lisp no longer deserves the term....
- I dare say that most Lispers these days (and possibly even most Schemers) don't give a damn what the FunctionalWeenies think of them. We're just trying to get a job done; we're not interested in religious wars about whose language is more pure. -- SmugLispWeenie
Reasons why LispLanguage is a functional language:
- Supports HigherOrderFunctions, one of the first languages to do so.
- However, some Lisps do it better than others. CommonLisp, by virtue of its separate function namespace, makes things harder than necessary. Old dynamically-scoped Lisp dialects have difficulty with proper lambdas (not being able to capture variables from the enclosing scope at the point of definition).
- The "funarg device" was present in Lisp 1.5, and that's pretty old. LISP 1.5 Programmer's Manual was published in 1962. Also see ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-199.pdf They didn't close over the lexical environment, but many old dialects could close over the dynamic environment. There is an example of this on the DynamicClosure page.
- However, some Lisps do it better than others. CommonLisp, by virtue of its separate function namespace, makes things harder than necessary. Old dynamically-scoped Lisp dialects have difficulty with proper lambdas (not being able to capture variables from the enclosing scope at the point of definition).
- It's a MultiParadigmProgrammingLanguage, with FunctionalProgramming as one of the supported paradigms.
Reasons why it isn't.
- Most Lisp programmers use an imperative style; SideEffects are common-place. ReferentialTransparency is almost non-existent.
- Lisp programs are not executed on a GraphReducer.
- Excluding SchemeLanguage, no mandatory TailCallElimination (a needed technique for a pure functional language).
- It's a MultiParadigmProgrammingLanguage... to be "functional" you gotta be pure. (The same argument, I supposed, used to argue that C++ isn't an OO language).
- DynamicTyping (many functional languages like to play with advanced static type systems...OK this isn't a very good reason).