Lisp/Clojure: Removing unnecessary parentheses through conventions

Question

I am fascinated to Lisp as it is simple yet powerful. I am just a beginner and I know there have been lots of discussions on removing parentheses from Lisp and its dialects. Yet I request Lisp ninja's to take few minutes answering this.

Will there be any side effects in Lisp/Clojure if they had followed 2 conventions below:

;; function declaration
defn function-name param-1 .... param-n
  ...
  function-body ;; not (function-body)
  ...

;; function call
function-name param-1 ... param-n ;; not (function-name param-1 ... param-n)

While still using () or [] for inline and nested expressions.

(println "hello, ") (println "world !!!") ;; inline    
= a (- 2 3) ;; nested

Answer 1

You can do that, and much more, using sweet-expressions. There is already a working implementation of sweet-expressions for Scheme, which I encourage you to study. The basic idea is that you replace the standard S-expression reader with a sweet-expression reader; everything else stays the same, and you retain homoiconicity and the ability to use macros.

The question is how to implement sweet-expressions in Clojure, since curly braces are already used as a notation for maps, sets, and metadata.

Answer 2

Lisps are very unique in how they are defined. Lisps are not defined in terms of text but in terms of Lisp data structures. E.g. in Python a function definition is defined like this:

the letter d followed by the letter e followed by the letter f followed by whitespace followed by an identifier denoting the name followed by the character ( followed by …

Whereas in a Lisp a function definition is defined like this:

a list with three elements, the first of which is the string "def", the second of which is a list of strings denoting the names of the parameters, and the third is the code of the function also represented as a list

Likewise, a function call is a list whose first element is a string denoting the name of the function to be called and the other elements are the arguments to the function.

How you write down those lists and strings is irrelevant. You could use the traditional Lisp syntax, you could use JSON, YAML, XML or whatever. The important thing is that code is just a data structure. How that data structure is represented is irrelevant.

Answer 3

As mentioned by Chris, sweet expressions are what you are looking for.

with respect to Clojure, you can write indented code with a plugin called indent-clj. You'd end up with something like this:

defn factorial [n]
  if (<= n 1)
    1
    (* n (factorial (- n 1)))

Sweet expressions also mention infix, discussed here for Clojure Clojure has yet to use the #[...] reader form, so it is possible to use #[n <= 1] for infix expressions. This would never get support, but here it is anyway:

defn factorial [n]
  if #[n <= 1]
    1
    #[n * (factorial #[n - 1])]

A fully supported way to implement infix today is to use a macro of course, or even Clojure's tagged literal facility to create a custom infix tag, say #nfx (...). It's a bit verbose, so I don't see any benefit over the normal way:

defn factorial [n]
  if #nfx (n <= 1)
    1
    #nfx (n * (factorial #nfx (n - 1)))

Sweet expressions also introduce "neoteric" expressions, that is the traditional function call syntax f(...). This seems impossible in Clojure, since spaces around collection delimiters are optional (e.g. (a(b)) is a valid list).