If we think Clojure is a 'diverging Lisp', then there are other diverging Lisps with different syntax like MDL, Logo, Dylan, even JavaScript. Some Scheme code uses angular brackets.

Historically core Lisp has left other grouping character or syntax to sublanguages or new data types. There are many examples for that. This is usually done via reader macros, which open up the s-expression reader to the programmer.

This is a Joshua rule:

    (defrule grandfather-determiner (:backward)
      ;; there are 3 ways to find your grandfather
      IF [or [is-genetic-grandfather-of ?gramps ?kid]
      [is-grandfather-thru-step-parent ?gramps ?kid]
      [is-step-grandfather-of ?gramps ?kid]]
      THEN [is-grandfather-of ?gramps ?kid])

Many internal or external domain specific languages for Lisp use special syntax and defining forms, since their authors either believed that it's easier to use in general or that it was necessary for 'end users' of their systems. Early examples were maths systems like Macsyma, which were programmable, but addressed mathematicians as audience. Logo, which was Lisp for kids. One of the first theorem provers had the first ML as the programming language interface for its users.

Historically Lisp 2 was supposed to get rid of simple s-expressions on the surface. There was a different syntax defined for it.

I was mostly talking about diverging in the way Fennel had.

> Historically core Lisp has left other grouping character or syntax to sublanguages or new data types.

Sure, but Clojure uses other grouping characters for the main dialect itself, and Fennel uses very similar deviations from the "Lisp baseline", hence my wondering about the inspiration.

Square brackets have been used in some Scheme for a long time. There are also Scheme books which use them in code.

Used them to define the formal parameters of a function? Because that's what I'm referring to. Fennel uses

    (fn [param*] expr*)

for function definition, which is also how it is spelled in Clojure.

One can use them everywhere instead of parentheses.

The difference for Clojure would largely be that other delimiters are sugar for the various data types, so you make maps with {}, vectors with [], sets with #{}, etc.

it then mixes syntax and data type issues. For example arguments are then vectors, probably to have [] as syntax. Though in Lisp one would keep argument lists: there is no technical need to make them vectors.

I wasn't making a value judgement in the statement, just nothing that in Clojure the other delimiters aren't just alternative ways to enclose forms.