Lambda the Ultimate

Yes, typing in the fun4j Lisp-subsystem is completey dynamic as in a traditional LISP implementation.

On the other hand the fun4j Java Collection API is statically typed and using Java generics.

So for instance mapping a lisp function over a Java Collection does need no explicit casts in the user code:

  Collection col = fun4j.asCollection(1, 2, 3, 4);
  Function square = fun4j.compile("(lambda (x) (* x x))"); 
  Collection result = fun4j.map(square, col);

The actual cast is done behind the scenes within the fun4j map method:

  public  Collection map(Function fun, Collection col) {
     Collection result = new ArrayList();
     for (E el : col) {
         result.add((F)fun.apply(el));
     }
     return result;
  }

sure, I've studied Clojure in some depth.

fun4j sits in different niche in the FP ecosystem.

Clojure is meant as a fullblown standalone programming language.
Fun4j provides a simple standalone LISP implementation, but also provides a functional Java API, for those who just want to embed certain FP elements (like higher order functions, collection processing) in their Java coding.

Clojure extends Lisp by constructs like STM and Agents.
Fun4j focuses on a rather tiny functional subset of Lisp (comparable to classic Lispkit).

FWIW, I don't think Clojure can or should be considered the be-all/end-all Lisp on the JVM. For one, Clojure is quite far removed from the "Lisp mainstream" (Common Lisp, Scheme, Dylan, ISLISP, EuLisp, Goo, ...), which has been going strong (err...) for more than half a century. I'm quite certain that I'll be able to use a CL or Scheme 1 or 2 decades from now on the JVM. Not so with Clojure.