How so? Can we program Haskell's Hindley-Milner based type checking into Lisp with macros and homoiconicity, and have it run during compile-time?
I've been dabbling in OCaml and ReasonML recently, and am enjoying pure functional programming a lot. But I never could get into untyped FP like the very practical Clojure before because they didn't seem to offer me too much compared to Ruby and Javascript.
Functions in ES6 are more first-class than Ruby's lambdas. The single-line function definition is very concise and you can also do your programming with immutable values if you are careful about references and use something like the immutable-helper. Granted you don't get persistent data structures, but then you have ImmutableJS now. ES6 implementations also have TCO, so a recursion-based programming model should be fine as well.
In that context, the differentiating power of Lisp seems to be around macros - a very powerful way to write programs that write programs. I have done my fair share of meta-programming with Ruby and I realized I really didn't want the power to change my program model at runtime. While they made certain things easier - like Rails's ActiveRecord (which is superb btw) - the "inception"-like indirection made things very hard to reason about.
For me the secret-weapon language is less about power, and more about structure. We can build equivalent things with any turing-complete programming language, but the test is when the system has to grow, and that is precisely when most codebases fail. So far, statically typed FP with Sum Types and Pattern Matching and Immutability seems to be the cure, and macros and dynamic typing its very antithesis.