Question

It seems as if everything needs to be wrapped in parenthesis in clojure. Even a simple hello world!

(println "Hello world!")

What is the benefit of that syntax decision?

Answer 1

The fundamental reason is that Clojure was designed as a homoiconic language, i.e. code is expressed in the core data structures of the language. All Lisps share this property, but few other languages do. As a result, the entire language design of Lisps is strongly influenced by this decision.

The choice was made early in the design of Lisp that lists would be used for function invocation in the form:

(function arg1 arg2 arg3) => some result

This has lots of advantages:

• A function call is expressed as a single data object known as a “form” (in this case the form is a list, but it could also be a vector, a hashmap, a literal value etc.). You can pass it around, modify it and transform it as needed before execution.
• It’s easy to construct such function calls using standard list operations – e.g. (cons function-symbol list-of-args)
• The syntax is very easy to parse – everything between two parentheses is a self-contained expression. This makes writing parsers easy, and also helps with tooling (see the incredible array of paren-handling commands in emacs for example)

The function name could have been put outside the parentheses:

function (arg1 arg2 arg3) => some result

But this would have many disadvantages:

• You can no longer express a function call in a single form. You’d have to pass around two separate data objects, the function name and the argument list.
• It would make the syntax more complex – you would need additional syntax rules to recognise this as a function call (e.g. extra delimiters like “,” between the arguments)
• It would be harder to do code generation. Lisp was designed from the start to allow effective code generation – on the other hand if you’ve ever tried generating C++ source code then you will know how hard it can be in a language not designed in that way.
• It does not actually reduce the number of parentheses overall. In fact, due to being a very concise language, Clojure usually ends up with less parentheses than equivalent code in Java / C#