Most languages have most of the listed features. The most interesting uncommon idea on that list to me is model of time. But only when it allows reversible computing. I don't know how practical that is though. Anyways I've separated out the parts of the list which I think are less common. And listed examples off the top of my head so by no means is the below meant to be exhaustive.

The uncommon ones:

* Units - F# and Frink

* homoiconicity - Lisps, Prolog, Io, Factor, Pure?, ...

* macros and extensible syntax - the above list, Nemerle, Dylan

* Unification - Prolog, Mercury - logic languages. anyone with type inference. anyone with predicate dispatch, a full example of which I do not know. F# Active patterns and scala extractors are close.

* Error (managing numeric Imprecision) - Best I can understand I can only note that I have seen people treat similar concepts with monads. So haskell and any language which allows easy monads. So scala, f#, haskell, clojure, nemerle

* Math types - Axiom/Aldor. To an extent, dependently typed languages - not practical. yet?

* Polymorphism - Although it sounds more like structural typing. So OCaml, Scala. Also F#, haskell partially.

* Aspects - Metaprogramming makes this relatively easy and clean to implement. so anyone with macros too. Arguably, monads are another way to follow the same philosophy.

* term rewriting - not common, very niche and not mentioned, but pure-lang allows this and for abstract math programming it is a really fun & powerful concept.

* pluggable types - F# has this as type providers. Gosu open types. I have used it in F#. At a start, it is a very awesome way to consume an api.

Less Uncommon:

* pattern matching - most functional languages. to a small extent the java.nexts

* Immutable values - most functional languages

* Parser - parser combinators or any language which implements PEGs e.g. Nemerle

* Design by contract - eiffel and as a library in most languages

* laziness - the usual functional suspects.