Lisp is an unique combination of design decisions which together produces an unique programming language.

It seems like this definition is general enough to be applied to almost any language, but it only seems so.

The key idea here is that it must be a minimal set of features, that is good-enough. The more bloated a language is - the less good it is.

So, what is the minimum set of features for a Lisp?

  - common underlying representation for code and data (a list structure based on conses).
  - one common syntax for describing code and data (prefix notation and paranthesys)
  - one general evaluation rule for all possible expressions with an exeption of *very few* special cases (less special forms - better).
  - general, environment-based evaluation strategy based on lexical scooping (the way to create closures).
  - tag-based type system - data has a type, not a variable (everything-is-a-pointer semantics).
  - list-aware reader function which perform transformations of lists
  - pointer-based, zero-copying FFI
  - REPL

Together this is what a modern Lisp is. This set of features produces the power and elegance of a Lisp. It holds for Schemes, CLs and Arc.

Clojure went its own way to stuff anything into a language (and ruin the miracle of a Lisp) and instead of being based on so to speak, real-memory data-structures uses JVM's abstractions, which together renders something that looks like a Lisp, but is completely different language, some next level, but worse, farther away.

It also worth of another analogy. Modern Lisp is already a creole language - a language evolved by generations of speakers, while Clojure (and most of other languages) is still a pidgin.)

Let's be clear though - this is your personal list of requirements. Be that as it may you should address how each of your points is in conflict with clojure.