Clojure Basics for Java Developers

(defn square [x]
    (* x x))

(deftest square-test
    (is (= 0 (square 0)))
    (is (= 1 (square -1)))
    (is (= 1 (square 1))))

I thought that you would have to be mad to use it. However, since functional programming has become more and more popular, I decided to give it a try and changed my mind (or became mad). In this post, I will try to share with you some of Clojure's (Lisp for the JVM) beauty.

Note: I'm still learning the language, so I might be oversimplifying things. If you're a seasoned Clojure programmer, you risk a heart attack reading this. :)

Hello World!

(println "Hello world!")

This is a "Hello World" program in Clojure (using REPL). The syntax is pretty basic:

• Everything goes in parens:

  (...)

  
  
• Function name goes first:

  (function-name ...)

  
  
• Then arguments, if there are any:

  (function-name arguments)

  
  

The square function, defined in the first listing, would be called like this:

(square 2)

As you can see, there aren't more parens in Clojure than there are in Java, you just move the paren to the left!

Java:                 Clojure
square(2);            (square 2)
square(square(2));    (square (square 2))

Math Operations

Math operations like + or * also go first in the expression. Actually, these symbols represent Clojure functions. It might take a while to get used to it.

(+ 2 2)
(- 2 2)
(* 2 2)
(/ 2 2)

Actually, this notation isn't any harder than the "normal" one — just remember that operation goes first.

Java:             Clojure:
2 + 2             (+ 2 2)
square(2);        (square 2)

Defining a Function

To define a function we use the defn macro.

1. We call defn:

   (defn ...)

   
   
2. Then we declare function's name:

   (defn function-name ...)

   
   
3. Then we declare the parameters in square brackets:

   (defn function-name [param] ...)

   
   
4. Finally we put the body:

   (defn function-name [param1 param2]
       expression1
       expression2)

   
   

Last expression in the body acts as a return statement.

Java:                             Clojure:
int f() { return 1; }             (defn f [] 1)
int g(int i) { return i; }        (defn g [i] i)

Now the square function should be easy to understand. We take an argument x and return (* x x). Piece of cake!

Conditions

There is an if construct (special form) in Clojure, but it works a bit differently than the Java keyword. It works the same as Java's ternary operator — it returns one of two values based on a condition. Here's the usage:

1. We call if:

   (if ...)

   
   
2. Then we enter a condition:

   (if condition ...)

   
   
3. Then goes the value to be returned when the condition is true:

   (if condition then)

   
   
4. Lastly, we can put a value to be returned when the condition is false:

   (if condition then else)

   
   

An example might help a lot in understanding:

(if (> x 0) "positive" "zero or negative")
(if (< x 0) "negative" "zero or positive")

If we want to chain conditions, like if-else in Java, we should use the cond macro. It's syntax looks like this:

1. Macro call:

   (cond ...)

   
   
2. List of conditions with associated expressions:

   (cond
       (< x 0) "negative"
       (> x 0) "positive")

   
   
3. Optional "else" expression:

   (cond
       (< x 0) "negative"
       (> x 0) "positive"
       :else "zero")

   
   

Solving a Real Problem

Enough learning for today. It's time to save the world by tackling the very famous "Fizz buzz" problem.

We'll start by defining a function taking one argument and returning it:

(defn fizzbuzz [x] x)

This solves problems for non-divisible numbers. Let's make a "fizz":

(defn fizzbuzz [x]
    (if (= x 3) "fizz" x))

That's a naive solution, because it doesn't work for 6, 9 etc., but we'll solve that later. Let's add a buzz:

(defn fizzbuzz [x]
    (cond
        (= x 3) "fizz"
        (= x 5) "buzz"
        :else x))

"Buzz" is there. With cond in place, adding "fizzbuzz" is trivial:

(defn fizzbuzz [x]
    (cond
        (= x 3) "fizz"
        (= x 5) "buzz"
        (= x 15) "fizzbuzz"
        :else x))

Perfect. It's high time to make the "fizz", "buzz", and "fizzbuzz" work for other numbers than 3, 5, and 15. We'll use the mod function for this:

(defn fizzbuzz [x]
    (cond
        (= 0 (mod x 15)) "fizzbuzz"
        (= 0 (mod x 3)) "fizz"
        (= 0 (mod x 5)) "buzz"
        :else x))

Notice, we had to move the "fizzbuzz" case up, because of the "fizz" and "buzz" conditions. That's it, world saved!

Conclusion

Despite the first impression, Clojure is a pretty simple language. Main constructs like functions, math operations or conditions are pretty similar to other languages. What's important, the language is capable of solving super-complicated problems like "Fizz buzz". I hope you had some fun!

Extra Watching

• Clojure for Java Programmers by Rich Hickey
• Clojure by Uncle Bob