Clojure Course - Control Flow and Functions

Clojure Course

Part 3 - Control Flow and Functions

Coming from imperative / OOP languages, it surely seems strange at first, that everything in Clojure is immutable. How can we get anything done, if we are not allowed to change stuff?

The answer is that clojurists use the superpowers of functions, collections and recursion to control the flow of programs. In functional programming, we break down the code into small, self-contained parts that focus on one task each. The program is composed up from these functions.

Binding Symbols

We discussed in the previous section that symbols refer to an object, value, function, etc. But how can we define our own? There are two ways:

(def symbol value) will bind the symbol to the global scope, or more precisely, to the current namespace.
(let [symbol value] expression) will bind the symbol to the local scope, so that the symbol is only valid inside the let form and can be used only within that expression. The symbol and its value are written in a vector.

In the next snippet, we declare that birth-year equals to 1981, but within the let scope we assign a different value to this symbol. The first println shows this local birth-date. Then the second println falls back to the global birth-date that was declared by def.

(do
  (def birth-year 1981)
  (let [birth-year 2002]
    (println birth-year)) ; local scope
  (println birth-year)) ; global scope

Note: the semicolon ; in the code means a comment. Any text after the semicolon is ignored by the compiler. The do form combines multiple expressions that are evaluated together, and the result of the last one is returned.

Declaring Functions

A function may take one or more parameters and produces an output value. We can express this with the form (fn [args] expression). We can list multiple symbol names inside the vector, those will be bound to the local scope of the function.

In the next example, we define a function that takes one argument, and returns the cube of that number. We immediately call this function with the value 5, so the result is 125.

((fn [x] (* x x x)) 5)

This form is actually an anonymous function. We can further simplify it with a different syntax, where the arguments are also not named. So instead of fn we prefix the function body with a hash sign, and we refer to the argument with the % (percentage) sign. So these two examples are equivalent.

(#(* % % %) 5)

When we want to declare a named function, we use the defn form, that is a combination of def + fn.

(defn cube
"Calculate the cube of a number"
[x]
(* x x x))

(do
  (println (cube 5))
  (println (map cube [1 2 3 4 5])))

In the function definition, first we assign the symbol cube to this function.
The next element is an optional docstring that explains the purpose of the function. This is used for automatic documentation.
Then we list the names of the parameters in a vector.
Finally the function body contains the actual logic that is executed, when the function is called. The result of that expression is the return value of the function.
We invoke the function by its name, and listing the arguments (in this case only one number).
Functions are first class objects, just like any symbol, so we can put them in collections and pass them around to other functions. In the last line we use the map function to apply cube over a vector of numbers.

Conditions

We can handle the most basic conditional expression with the form (if test then-expr else-expr), which is very much like if-then-else in other languages. The false branch is optional. The predicate is a boolean expression. In Clojure, only nil and false have a falsey value, anything else is truthy.

A few examples:

(let [x 23]
  (if (odd? x)
    "x is odd"
    "x is even"))

(if false 
nil
"only the false branch yields a result here")

(if "" 
"empty strings are truthy")

The cond macro can handle multiple conditions, and a default case when none of the conditions are fulfilled.

(let [age 12]
  (cond
    (< age 18) "Too young"
    (> age 70) "Too old"
    :else "Between 18 and 70"))

The case macro works like a switch statement in other languages. It can also have a default case.

(case :paper
  :rock "Rock!"
  :paper "Paper!"
  :scissors "Scissors!"
  "Invalid guess...")

There are many other similar macros to handle conditions / branches in the standard library (clojure.core), each suited to a specific usage pattern.

Loops

Now this is going to be very different from a typical for loop we've seen in imperative languages. The essence of loops is to repeat the same operation multiple times. But if we can't mutate anything, not even a "loop variable", then how do we do this?

One way is to apply a function, such as map, filter or reduce over a collection. We leave this for next time though, and now we look at another option in Clojure: recursion.

Let's take a look at a simple countdown code and analyse how it works:

(loop [counter 5]
  (if (zero? counter)
    (println "Boom!")
    (do (print (str counter "... "))
        (recur (dec counter)))))

We begin with the loop form, and bind the starting value to the symbol counter, the same way as we have previously done with let and fn.
The exit condition is that counter reaches 0. We check this with the zero? built-in predicate function. If this is true, then the bomb explodes and the loop is finished.
If we are not there yet, then we want to do two things: print the current value of counter, and repeat the cycle with the next value. We can combine multiple expressions with the do special form.
The str function concatenates its arguments to a single string, so we can print it.
Finally, recur sends us back to the start of the loop, and we need to provide what will be the new value of the counter. We decrease the current value by 1, using the dec function. It is important that recur must be the very last command inside the loop.

We can use similar logic to write a recursive function, which calls itself multiple times, until an exit condition is reached. For example, to calculate the n-th Fibonacci number recursively, we can do this:

(defn fib
"Calculate the n-th Fibonacci number recursively"
[n]
  (if (< n 2)
    n
    (+ (fib (dec n)) (fib (- n 2)))))

; Test: printing some elements of the sequence
(println (fib 8) (fib 10) (fib 12))

The Fibonacci sequence starts with fib(0) = 0 and fib(1) = 1, then the next element is always the sum of the last two numbers. So thinking backwards, we can define fib(n) = fib(n-1) + fib(n-2). We calculate the target element from the two previous elements recursively, until we reach element 0 and 1, which is the exit condition of the recursion.

It must be noted that this version is very wasteful, because it recalculates the previous elements of the sequence many times. We can write much more efficient solutions with Clojure, for example involving memoization or lazy sequences. We must save some advanced topics for later :)

About Pure Functions

Try thinking of functions as if they were mathematical equations. They receive certain inputs, do some magic on them in a black box, then spit out other values as output. In functional programming, we aim to write pure functions most of the time. What does that mean?

A pure function has no side effects. It does not modify anything outside its scope, it does not mutate any global or shared state.
A pure function does not depend on any extra information, apart from its inputs, to do its job.
Referential transparency: if we give the same input, we always get the same output, whatever happens.
Pure functions are easier to test and less likely to cause bugs.
Pure functions are easy to handle in concurrent or multithreaded programs.

To realize these benefits, we try keeping most parts of our program pure. However it will never be perfect, because ultimately we write programs to achieve some effects in the world, hence we need to mutate the world's state. Input and output (I/O) operations will always be impure. For example, we cannot be sure if the file we're trying to read, has been changed in the meantime, or some other process may have written something to the output device.

Also, impurity is contagious: if we call an impure function from an otherwise pure one, the caller will get infected too and become impure. To deal with this, we can push all impurity to the edges of our program, and try to keep the core as pure as possible.

We can reach some level of purity in most programming languages, but Clojure gives us excellent support for this, with its native immutable data structures and functional programming toolset.

Next time we will explore the collections of Clojure and how to harness their power. Stay tuned! :-)

[Clojure] 03 Control Flow and Functions