What are the practical benefits of LISP like syntax which Clojure uses over Java like syntax of Scala

clojurelispscala

I spent couple of months learning Scala and got overwhelmed by number of different constructs it had,
After looking at partial functions, partially-applied functions, pattern matching, actor syntax,
I gave a thought to learning Clojure which doesn't have too much in terms of syntax but looking at the how Java inter-operability is handled, it looks very difficult to get use to.

for example: things like doto, new and .

Every time I start typing a function, there are times I write (1 + 2) instead of (+ 1 2).

It looks like I will have to completely forget how I write regular programs to get use to this syntax.

Also finding it difficult to deal with side-effects that do and let form have.
Aren't they similar to what functions with void type are ?

Things like registering a callback,things normal I/O, how can such things be side-effects free.

Till now all I really liked about Functional Programming is that,
immutability makes concurrency easier when dealing with shared data,
functions as first class objects and having higher-order functions,
apply,map and reduce with functions and lists
.

I wanted to know, are there practical benefits I will get once I am use to this syntax ?
I f I continue to learn Scala and avoid using var, and always use recursion instead of loops.
I can do all the above things and still write understandable code.

Best Answer

Lisp syntax is just that: syntax. It has nothing to do with semantics. In other words, the syntax (ideally) shouldn't affect how you write programs; if you feel like you have to "completely forget how you write regular programs", it sounds like you're having difficulty with the semantics, not with the syntax.

Practical benefits of Lisp syntax include:

consistency. Function/macro/special-form followed by its arguments. No operator precedence issues. Grouping is usually explicit.
easy to parse and unparse. This makes it easier to write source code tools, such as static analyzers and code browsers.
extensibility
- user-defined macros. Users can extend their Lisp system's syntax.
- system-defined syntax. New special forms can be added to a Lisp system without having to worry about how their syntax interferes with existing forms.

You also threw in a couple of questions about side effects and functional programming. Those aren't related to Lisp syntax and should really be asked in a separate question.

Related Solutions

Java – Performance of Scala compared to Java

There's one thing that you can do concisely and efficiently in Java that you can't in Scala: enumerations. For everything else, even for constructs that are slow in Scala's library, you can get efficient versions working in Scala.

So, for the most part, you don't need to add Java to your code. Even for code that uses enumeration in Java, there's often a solution in Scala that is adequate or good -- I place the exception on enumerations that have extra methods and whose int constant values are used.

As for what to watch out for, here are some things.

If you use the enrich my library pattern, always convert to a class. For example:

// WRONG -- the implementation uses reflection when calling "isWord"
implicit def toIsWord(s: String) = new { def isWord = s matches "[A-Za-z]+" }

// RIGHT
class IsWord(s: String) { def isWord = s matches "[A-Za-z]+" }
implicit def toIsWord(s: String): IsWord = new IsWord(s)

Be wary of collection methods -- because they are polymorphic for the most part, JVM does not optimize them. You need not avoid them, but pay attention to it on critical sections. Be aware that for in Scala is implemented through method calls and anonymous classes.
If using a Java class, such as String, Array or AnyVal classes that correspond to Java primitives, prefer the methods provided by Java when alternatives exist. For example, use length on String and Array instead of size.
Avoid careless use of implicit conversions, as you can find yourself using conversions by mistake instead of by design.
Extend classes instead of traits. For example, if you are extending Function1, extend AbstractFunction1 instead.
Use -optimise and specialization to get most of Scala.
Understand what is happening: javap is your friend, and so are a bunch of Scala flags that show what's going on.
Scala idioms are designed to improve correctness and make the code more concise and maintainable. They are not designed for speed, so if you need to use null instead of Option in a critical path, do so! There's a reason why Scala is multi-paradigm.
Remember that the true measure of performance is running code. See this question for an example of what may happen if you ignore that rule.

Understanding clojure keywords

the & in (defn full-name [& {first :first last :last}] indicates that all the remaining arguments should be gathered into a single collection. the map destructuring form following the & then takes the map created by the & apart again.

(defn full-name [& {first :first last :last}]...)
(full-name :first "Tom" :last "Brennan")

without the & becomes

 (defn full-name [{first :first last :last}]...)
(full-name {:first "Tom" :last "Brennan"})

for your other question: symbols and keywords implement the function interface so they can be called just like any other Clojure function. when called as a function they look themselves up in their argument which they expect to be a map (or something implementing the appropriate interface)

Best Answer

Related Solutions

Java – Performance of Scala compared to Java

Understanding clojure keywords

Related Topic