How do we know that

  def fac(n): n < 2 ? n : n * fac(n - 1)

is the whole function? Maybe someone snipped

  def fac(n): n < 2 ? n : n * fac(n - 1)
              + more stuff

One of the parentheses you have there come from having an unambiguous, complete, top-level form. We know nothing has been cut off; any characters after the last closing parenthesis are not part of this form. Curly-brace languages agree with this and do the same.

One level of parentheses comes from using a dialect which uses a variable definition and lambda to define a function, instead of having function-defining syntax like defun.

   n < 2 ? n : n * fac(n - 1)

requires knowledge of the ternary operator and its precedence. Someone who has no clue about the ternary operator will not make heads or tails out of this. The Lisp is impossible to mis-parse, even by a programmer who doesn't know Lisp. You might not know how if works, but you can't miss the fact that (if ...) is a unit, which is enclosing four things: if, (= n 0), 1, and (* n ...).

You've loaded the readability dice by writing it on one line. To help with the readability issues in both languages, we can use multiple lines and indentation:

   def fac(n):
     n < 2
     ? n
     : n * fac(n - 1)

   (defun fac (n)
     (if (< n 2)
       n
       (* n (fac (- n 1)))))

yes, lisp is a fossil of a time before precedence was invented.

what I dream of is a Lisp with an additional mechanism to define precedence of functions/operators. And infix operators. Almost like Haskell.

> mechanism to define precedence

Read syntax:

https://en.wikipedia.org/wiki/CGOL [1973!]

https://www.cliki.net/infix

Macros:

https://stackoverflow.com/questions/25434538/define-function...