Clojure

Its better to search for local Clojure and GNU/Linux communities and become friends with them. If you can find one, consider joining them. Those are the best ways to get help. One may look here https://clojure.org/community/user_groups for nearby group.

The Clojure website may be a good starting point to browse for help if you have the time and patience. One may visit it here https://clojure.org/.

The official Clojure forum is here https://ask.clojure.org/, one may join it and start asking questions. Some of my initial doubts were cleared by this forum.

Clojure has a second forum here https://clojureverse.org/, it’s called Clojureverse this one too seems to be popular.

Reddit also has a Clojure community. If you are a reddit user, one may find the community here https://www.reddit.com/r/Clojure/.

Clojure works on all operating systems. You can install Clojure by following the link here: https://clojure.org/guides/install_clojure. Once installed, it is time for us to check the Clojure REPL. (To learn what a REPL is, check out https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop). Type clj in your terminal, and you should see something like this:

That’s the Clojure REPL. Now type (println "Hello World") in it as shown below and press ENTER.

You will see Hello World printed out as shown:

There is also a nil after Hello World. Don’t worry too much about that; we will see what that is later. After the nil, you will see user⇒ once again, which means Clojure is waiting for you to type another command for it to execute.

If you want to exit the Clojure REPL, press CTRL+D. You will get back to your terminal prompt.

Leiningen is a tool that automates tasks like setting up a Clojure project. Please refer to its website https://leiningen.org/ and install it. Once installed, type lein repl in your terminal, and you should see this:

Press CTRL+D to exit. All is well, and you have successfully installed Leiningen.

Open or create the file ~/.lein/profiles.clj and add the following content to it:

When I first started studying Clojure, I was introduced to REPL-driven development. I didn’t understand what it was in my early days; even if you don’t get it yet, don’t worry, you eventually will. In this section, let’s get a taste of REPL-driven development.

First, let’s print Hello World!. Copy the code below, paste it, and execute it:

Output

You will see Hello World! followed by nil on the next line. For now, you can ignore nil; we will discuss it when we cover functions. For this task, our mission is accomplished.

Commenting is essential in coding. Comments are notes for the developer reading the code, and the computer ignores them during execution. In Clojure, everything that follows a semicolon ; is a comment. So in the code below:

Output

; Says Hello to this world is a comment that the Clojure interpreter ignores. In the code above, we are adding a comment on the same line as the code; by convention, a single semicolon ; is used for this purpose. If you want a whole line dedicated to a comment, use two semicolons ;; as shown below:

Output

Both single and double semicolons function the same way, but this is the established convention in Clojure for inline comments versus dedicated comment lines.

We have printed Hello World, but what if we want to print multiple things? With println, it is simple: just provide additional arguments, and it will print them as shown:

Output

So you have successfully printed something in Clojure.

In this section, let’s explore mathematics in Clojure. First, let’s add two numbers, 40 and 2:

Output

In the expression above, we use the plus + symbol (which is actually a function in Clojure). We pass 40 and 2 as arguments to this function, which adds them and returns 42. Similarly, let’s see what happens when we pass 44 and 2 to the minus - symbol:

Output

It subtracts the second argument, 2, from 44 and returns 42.

Now, let’s see what happens when we pass 6 and 7 to the asterisk * operator:

Output

It returns 42, which is the product of 6 and 7.

Now, let’s see what happens when we pass 210 and 5 to the slash / operator:

Output

210 is divided by 5, resulting in 42.

Now, let’s see what happens if we pass more than two numbers to the + function:

Output

All the numbers are added together, and the sum is returned.

Look at the code below; can you figure out how it works?

Output

Consider the expression (/ (+ 1 2 3 4 5) 5). Focus on the innermost parentheses, (+ 1 2 3 4 5), where several numbers are passed to the ` function, which returns their sum: 15. Substituting 15 for `( 1 2 3 4 5) gives us the expression (/ 15 5), where 15 is divided by 5, resulting in 3.

Now, let’s pass more than two arguments to /. For example, passing 1, 2, and 3 results in \$1/6\$:

Output

The output above is a fraction (a ratio). To obtain a decimal result, append .0 to at least one of the numbers passed to /:

Output

As long as at least one number passed to / is a decimal (indicated by the . symbol), the result will be a decimal rather than a fraction:

Output

The same applies here:

Output

To get the quotient of a division, you can use the quot function:

Output

To get the remainder of a division operation, use the rem function:

Output

Let’s calculate the area of a circle using Clojure. The area is \$pi r^2\$, where \$pi\$ is approximately \$22/7\$. This can be coded as follows:

Output

In this expression, \$pi\$ is represented by (/ 22 7) and \$r^2\$ (where \$r\$ is 7) is represented by (* 7 7). Multiplying these together results in (* (/ 22 7) (* 7 7)), with an output of 154N.

Adding .0 to any of the numbers removes the N:

Output

Instead of using (/ 22 7) for \$pi\$, we can use the Java Math library, as Clojure is hosted on the JVM. This allows Clojure to leverage powerful libraries provided by the host platform. We can replace (/ 22 7) with Math/PI as shown below:

Output

Similarly, to compute \$x^y\$, we can use Math/pow. Replacing (* 7 7) with (Math/pow 7 2) looks like this:

Output

There are different types of numbers in computing, just as there are different types of numbers in mathematics. For example, whole numbers are called Long in Clojure. You can verify this by passing a whole number to the type function, which tells you the type of data passed to it, as shown below:

Output

Numbers with decimal values are called Double in Clojure, as you can see below:

Output

The value of \$pi\$ is also a Double in Clojure:

Output

If a Long (whole number) is divided by another Long, the result is a Ratio in Clojure:

Output

As shown below, (/ 84 32) in Clojure does not provide a decimal value, but instead outputs a Ratio:

Output

You can convert one type of number to another; for example, 32 is of type Long:

Output

you can convert it to a Double by passing it to the double function, as shown:

Output

When you query its type, it returns Double:

Output

If you want to prevent the division of two Long`s from resulting in a `Ratio, convert at least one of the arguments passed to the / function into a Double, as shown below:

Output

The result is a Double rather than a Ratio:

Output

To get only the non-decimal part of a Double, pass that Double to the long function:

Output

As you can see, when a Double is passed to the long function, it is cast to a Long:

Output

Your very first Clojure program in this book was likely this:

It prints Hello World! on the screen. The text "Hello World!", enclosed in double quotes, is a sequence of characters known as a string.

Anything enclosed in double quotes in Clojure is a String, as shown below:

Output

Strings can be concatenated with other data types using the str function:

Output

In the code above, (+ 1 2) returns a Long, but it can be concatenated with the string "1 + 2 is " by passing both to the str function.

You can determine the number of characters in a string using the count function:

Output

In the code below, we pass six arguments to the str function: five numbers and a final string, " and so on…​":

Output

Clojure concatenates these values and returns a single string.

Clojure has a built-in string library; you can read the documentation at https://clojuredocs.org/clojure.string. Let’s use the reverse function to reverse a string:

Output

Now, let’s convert all characters to uppercase:

Output

This section provides a brief introduction to strings. You will learn more as you progress. Stay tuned!

Imagine variables as boxes that contain a value; they make the code more human-readable. For example, look at the code below:

Output

I have assigned the string "Karthik" to a variable named my-name. Now, my-name can be used anywhere in the Clojure code. When defining a variable, there are three main components. First, the parentheses:

Then we have the def function:

Following def is the variable name; in this case, it is my-name:

The second argument to def is the value to be stored in my-name, which is "Karthik" in this example:

This is how we define a variable. A variable defined with def is typically called a global variable, meaning it is available anywhere in the program. If this isn’t clear yet, don’t worry.

Now we can print this variable as shown:

Output

Here, I am adding "Hello " before the variable my-name, which is equivalent to using the string "Karthik":

Output

Look at the code below:

Output

I have defined a variable called greeting and assigned it the result of (str "Hello " my-name "!"). This joins three strings—"Hello ", my-name, and "!"—and stores the result in greeting. Finally, we print it using (println greeting).

Variables like my-name and greeting can be used anywhere in the code because they are defined using the def keyword. To define a local variable within a specific block (), use let as shown:

Output

In the code above, we define a variable named local-variable with the value "something" and print it. However, outside the (let …​) block, this local variable does not exist, as shown below:

Output

Attempting to print local-variable results in an error.

Up until now, you have likely run your code in a REPL, either in your terminal or in an IDE (such as VSCodium). Now, let’s see how to store your code in a file and run it. First, create a new file in your text editor named as follows:

Save the code as hello_world.clj. Then, in your terminal, cd to the directory containing the file and run the following command:

The entire program will run, and you will see Hello World as the output. It should look like this:

Imagine a rack with many compartments; the first compartment is labeled 0, the second 1, and so on. You can put something into this rack and retrieve it if you know the compartment number, also known as the index. This is a real-world analogy for vectors.

Look at the code below:

Output

This is how you represent a vector in Clojure. It starts with an opening square bracket [ and ends with a closing square bracket ]; everything in between are the elements of the vector. In the above code, you have four elements: 1, 2, 3, and 4.

Another way to create a vector is to pass arguments to a function called vector, as shown below:

Output

In the above code, we passed 1, 2, and 3 to the vector function, and we get the vector [1 2 3].

So far, we have seen vectors created with numbers; in reality, you can create a vector with any type of value:

Output

In the above code, we created a three-element vector with 1 (a Long), true (a boolean, which you will learn about soon), and "Bashir" (a String).

In the code below, we define a variable named friends and assign it a vector containing four names:

Output

Now let’s see what the first element of the vector friends is. To do that, we pass friends to a function named first:

Output

This returns the first element of the vector.

There is a function called rest which, when given a vector, omits the first element and returns the rest of the elements in the vector, as shown below:

Output

As you can see, "Ram" is ignored because it is the first element, and the rest is returned.

Let’s check the type of friends:

Output

From the output, it is clear that it’s a vector, but let’s check what type rest returns:

Output

Although it seems to return ("Bashir" "Antony" "Buddha") (not enclosed in square brackets), querying the type reveals it is a chunked sequence of the passed-in vector.

We can access any element by its index in the vector using the nth function, whose first argument should be a vector and the second should be the index number, as shown:

Output

At index 3 of friends, the value is the string "Buddha".

The element at the third index can also be accessed as shown:

Output

It seems that when you define friends as a vector, Clojure allows you to use friends as a function that takes an index and returns the value at that position.

To add an element to the end of a vector, use the conj function, which takes a vector as the first argument and the value to be added as the second:

Output

In the above code, we added "Periyaar" to friends, but this does not mean that friends has been modified. We can print friends:

Output

And it still shows the original values without "Periyaar". In reality, Clojure constructs and returns a new vector when we call (conj friends "Periyaar").

To add an element to the beginning of a vector, use cons as shown below:

Output

Does it modify friends? Research the concept of immutability ^[4] in computing.

Lists are very similar to vectors. The primary difference is that vectors are enclosed in square brackets [ and ], while lists are enclosed in round parentheses ( and ). In fact, an entire Clojure program is a list. For example, to calculate \$3 + 5\$ in Clojure, we write (+ 3 5). Because it is wrapped in round parentheses, it is a list.

All Clojure code consists of lists. A list starts with an opening parenthesis ( and is typically followed by a function to call. For instance, to add two numbers, we use the ` function. This starts as `(, followed by the arguments passed to the function—such as 3 and 5—resulting in (+ 3 5. Finally, a closing parenthesis ) completes the list: (+ 3 5), which can then be executed by the Clojure interpreter.

Take a look at the example below:

Output

In the example above, we have built a list of four numbers. However, notice that we do not start with a (, but with an apostrophe followed by a parenthesis, like this: '(. This tells Clojure not to execute the content within the parentheses.

When you try it without an apostrophe, Clojure assumes 1 is a function and that 2, 3, and 4 are the arguments passed to it. It then tries to execute it and fails, as shown below:

Output

The apostrophe before the parentheses tells Clojure not to execute '(1 2 3 4), but rather to treat it simply as a list.

You can also create a list using the list function, as shown below:

Output

Above, we passed 1, 2, and 3 to the list function, and we get a list returned.

In the code below, we are creating a list of four strings and assigning it to a variable friends-list:

Output

Note how we are using the apostrophe in '("Ram" "Bashir" "Antony" "Buddha") to tell the Clojure interpreter not to execute the list.

Now let’s see how many elements are in friends-list. To do that, we use count as shown below and pass friends-list to it:

Output

Thus, count indicates there are four elements in friends-list.

Let’s get the first element in friends-list. For that, we use the first function as shown below:

Output

Now let’s get all elements except the first one in friends-list. For that, we use the rest function as shown below:

Output

Now let’s get the fourth element in friends-list. For that, we use the nth function, which takes a list as the first argument and the index to be fetched as the second argument.

Output

Note that list indexing starts at zero. That is, the first element is indexed 0, the second is 1, and so on.

In the example below, let’s try to get the fourth element of friends-list by passing the number 3 to it directly:

Output

And it fails.

Now, let’s add an element to the list. For that, we use the conj function. With conj, we pass the list to which the element should be added, followed by the element itself, as shown below:

Output

A set is a collection of unique items. Imagine a list or a vector where no two items repeat; that’s a set. In Clojure, you can create a set as shown:

Output

A set starts with a hash symbol and an opening curly brace #{, followed by the set items, and ends with a closing curly brace }.

Below, we query the type of the set:

Output

It returns clojure.lang.PersistentHashSet, which might be confusing to beginners. Instead, one can use the set? function to check if something is a set, as shown below:

Output

Since #{1 2 3 4} is a set, it returns true.

A set can have only unique elements. If we try to create a set with non-unique elements using a literal, it will throw an error, as shown:

Output

Let’s create a set of unique fruit names:

Output

Now, when we try to create a similar set with a duplicate element, "Apple", it throws an error, as shown below:

Output

Let’s create a set of fruit names and assign it to a variable named fruits, as shown below:

Output

Now we can check if fruits contains "Banana", as shown below:

Output

It returns true because fruits contains "Banana".

Now let’s check if fruits contains "Jack Fruit":

Output

It returns false because "Jack Fruit" is not part of fruits.

You can also check if a set contains an element by using the set itself as a function, as shown below:

Output

In the code above, we pass "Banana" to fruits, and it returns "Banana" because it is present in the set.

When we pass "Jack Fruit" to fruits, it returns nil because "Jack Fruit" is not in the set:

Output

Now let’s see what happens if we try to pass fruits to "Banana", as shown below:

Output

It fails.

Clojure also has a special data type called keywords. Their syntax is a colon followed by a name, such as :<some-name>. For example, if we want a set of programming languages, we can define it as follows:

Output

In this case, every element in programming-languages is a keyword.

Now let’s check if programming-languages contains :ruby:

Output

It does.

Now let’s check if it contains :java:

Output

It does not.

You can also check if an element exists in programming-languages by passing the element to the set:

Output

Since :ruby is in programming-languages, it is returned.

Because :ruby is a keyword, it has special properties that strings do not have. Recall that attempting to check if "Banana" exists in fruits using ("Banana" fruits) failed. However, checking if :ruby exists in programming-languages using the same pattern works, as shown below:

Output

We can add an element to a set using the conj function. In this case, let’s add :perl to programming-languages:

Output

Similarly, we can remove an element from a set using the disj function. Let’s remove :python from programming-languages:

Output

That covers the basics of sets for now.

Lists and vectors can be accessed using numeric indices, as shown in the following code:

Output

We get "five" as the output. But what if we want to use more user-friendly words as indices for our data collection? This is where maps come in.

Look at the code below, then type and execute it:

Output

In the above code, we create a map where the first element has the key "name" and the value "Bashir", and the second element has the key "age" and the value 12.

Instead of using curly braces, we can create a map by passing keys and values to the hash-map function, as shown below:

Output

The hash-map function takes keys as odd-numbered arguments and values as even-numbered arguments. In the code above, "name" is mapped to "Bashir" and the key "age" is mapped to the value 20.

Now, let’s create a map and assign it to a variable named friend:

Output

Now we can retrieve the value associated with the key "name" from friend using the get function, passing the map as the first argument and the key to be fetched as the second:

Output

The code above looks for the key "name" in friend, and its corresponding value, "Bashir", is returned.

There is also a shortcut to retrieve a value from a map: treat the map itself as a function and pass the key to it, as shown below:

Output

In the example above, we have the map friend; by passing the key "name" to it, we receive the mapped value "Bashir".

The type of "name" is a string, as seen below:

Output

Clojure also has keywords, which are preceded by a colon : followed by the keyword’s name. As you can see below, :name is a keyword:

Output

Instead of using strings as keys, let’s create a map with keywords as keys:

Output

In the code above, we create a map where the key :name is mapped to "Periyaar" and the key :age is mapped to 90. We assign this map to wise-friend.

Now we can retrieve the :name of wise-friend as follows:

Output

Similarly, we can retrieve the :age of wise-friend as shown below:

Output

In the above example, we use the get function, passing the map as the first argument and the key as the second.

In the following example, we extract the name of wise-friend using (wise-friend :name) and pass it to print, along with a second argument, "is very wise.":

Output

The output is Periyaar is very wise.nil. Try replacing print with println in the example above. What do you observe?

Since we used keywords as keys in wise-friend, we can also retrieve a value as shown:

Output

In the above code, we treat the keyword :name as a function and pass the map wise-friend to it to fetch the value.

Now, let’s add a new key-value pair to wise-friend:

Output

In the code above, we use the assoc (associate) function. We pass the map wise-friend, followed by the key :belief and the value "Rationalism". In Clojure, data structures are immutable. The operation above returns a new map {:name "Periyaar", :age 90, :belief "Rationalism"}, and since we did not assign it to a variable, the result is not stored. You might think that wise-friend was modified to include the new key and value. However, if you query wise-friend for :belief, it will return nil:

Output

All original values in wise-friend remain intact. Let’s query its age:

Output

Now, let’s remove a key-value pair from wise-friend as shown:

Output

In the code above, we remove :age from wise-friend, resulting in a map containing only the :name. Once again, it is important to remember that Clojure did not change the original wise-friend map. The dissoc (disassociate) function takes wise-friend as the first argument and the key to be removed as the second, creating and returning a new map without that key. In Clojure, data structures are immutable.

If we query the keys of wise-friend, we still see both :name and :age, as shown:

Output

To get the values stored in the map, pass it to the vals function, as shown:

Output

wise-friend has the key :name (a keyword) and we can also use "name" (a string). This means you can have a map with both a keyword and a string as keys, even if they are spelled the same, as seen below:

Output

By adding "name" as a key and associating it with the value "Ramasamy", we create a map with both :name and "name" as keys. Although this is possible, it is highly discouraged for the sake of code clarity.

If you had seen past few sections, you would have noticed vector is created by putting things between square brackets, and we can create a list by putting things between '( and ). Apart from that all operations are the same. So what’s the real difference?

Imagine vector is a rack. Each compartment of the rack is named 0, 1, 2 and so on till n.

You can put anything in the compartment that’s after the last filled one. See the example below:

Output

In the above code, we add "five" to numbers and Clojure adds it to the last. A vector is a huge rack of contiguous spaces. Clojure can easily access any of the rack very easily because it’s stored in a compact form in the memory. So even if you have a million element vector accessing the 7,546^th is fast in Clojure. Like every thing this comes with a catch. Say you have a million element vector, and you want to add another element, if the adjacent space in memory is not available and is occupied by some other thing, Clojure should do the huge work finding continuous free space, then it must move all elements to it and add the new value at the end. This process of moving around data is very costly.

So if speed of random access with index is not important, and you need only sequential access, and if you want to add a lot of values to your collection, and you have large list to be stored, consider list.

An element in a list has two parts. One is the value, and another one is a pointer to the next element. So elements of a list can be anywhere in your computer memory as shown below.

Adding a new element means it will have the value you push to it, and its pointer will point to current first element. So now the new value is the first element of the list. The drawback is, if you want to access the n^th element of a list, then Clojure needs to traverse through n - 1 elements to get to it. The positive is adding element is very easy.

Clojure has a function named doc. You pass any valid function name to it. For example, if we pass + to doc, its documentation is printed:

Output

From the documentation above, we can see that + can receive no arguments and will return zero:

Output

This is confirmed by the output above. We can also infer that + accepts a single argument and returns that number:

Output

This is also true. Finally, we can infer that + accepts two or more arguments and returns their sum, which is verified below:

Output

Output

If you want to search the entire Clojure documentation text, you can use the find-doc function as shown below:

Output

Above I have found functions whose documentation contains the string "sum of nums".

If you want to search for functions whose names contain a specific string, use the apropos function as shown below:

Output

Above, I used the apropos function to find all functions whose names contain the string "replace". Now, let’s check the documentation of the replace function to see what it does:

Output

If you are not comfortable using the Clojure REPL to access documentation, you can use Clojure’s online documentation available at https://clojuredocs.org/

In the image below, searching for reduce shows all functions whose names contain the word "reduce".

Clicking on reduce displays its documentation:

ClojureDocs is a convenient way to access documentation in a browser.

if is one of the basic condition checking functions in Clojure. Let’s try out a simple example. Execute the code shown below:

Output

We get the result 5 is positive as shown above. So we get the following, to an if the first argument is condition check, over here its (> a 0), if the condition check returns true, then the second argument passed (println a "is positive") is executed.

Now modify the program as shown:

Output

In the above code, a is -5 and hence (> a 0) fails. In theory then the third argument passed to if should execute, we have first argument (> a 0), and second argument (println a "is positive"), there is no third argument, so nil gets returned.

Now let’s give a third argument to it, see the code below and execute it:

Output

In the above code a is -5 and hence (> a 0) fails. In then the third argument should execute. In this case, the third argument is (println a "is negative") gets executed and -5 is negative gets printed out.

Take a look at the code below, execute it.

Output

So in the above code (> a 0) is true, so the first argument passed to it (println a "is positive") is executed and above output is printed.

Now let’s change a to -5 and see what happens.

Output

So the second argument passed to if is:

This argument itself contains a if, let’s call it nested if, and here the condition passed to it (< a 0) passes, so the second argument passed to the nested if (println a "is negative") gets executed and -5 is negative gets printed out.

Now what if a is zero, once again it comes to the second argument to the top level if, which is

In the code above (< a 0) fails, and the third argument passed to nested if (println a "is neither positive nor negative") gets executed, and we have execution as shown below:

Output

if function can accept only 3 arguments, the first one is a condition, the second argument will get executed when the condition passes, the third will get executed when condition fails. So what if we want to execute more than one statement if a condition passes or fails, well, wrap them in do as shown:

Output

Now let’s make a negative and execute it:

Output

if accepts a condition as first argument, as second it accepts what should be done if the condition is true, and third is what should be done if the condition is false. if does work when the third argument is left out, but if we want to execute a bunch of statements when a condition is true, then we can use when as shown below:

Output

Type the above program and execute it. When print-something is true, then the statements:

in the form

get’s executed, and we get the output shown above.

Now let’s set print-something to false as shown below and execute the code:

Output

Nothing gets printed. So if the first argument passed to when is true, all statements enclosed in its form gets executed, else nothing happens.

What if you want to check multiple conditions and execute different code based on which one is met? Welcome to cond (short for conditional). Take a look at the example below and try executing it:

Output

It prints 5 is positive because we set number to 5 using the let binding. The cond form is structured as follows:

In this code, since number is greater than 0, the condition (> number 0) is satisfied, and the associated expression (println number "is positive.") is executed.

Try changing number to a negative value, execute the code, and observe the result. If no preceding conditions are satisfied, the :else clause is executed:

Set number to 0 and execute the code to see the result.

Now, try executing the following code and analyze its behavior:

Set number to 0, execute it, and observe what happens.

Below is an example of case, type it and execute it.

Output

We get "I don’t know", so what happens? We have set num to 20 in let [num 20], then we pass num to case as shown:

So case checks the value of num. Since num is not 1, the statement 1 "one" is not touched.

Similarly, num is not 2, 3, 4, or 5, so all the statements below are not touched.

Finally, the default case "I don’t know" is executed as shown below:

And it gets returned.

As an exercise, remove the "I don’t know" and run the code. What do you get? Change num to 4 and run the code. What do you get? How can you explain it?

When num is 4, and "I don’t know" is removed, does it matter? Why?

When num is 20, and "I don’t know" is removed, does it matter? Why?

The first construct we’ll look at is for. Type and execute the following code:

Output

Let’s see how it works. The expression

binds [1 2 3 4] to the symbol nums. Then we use for as follows:

In the expression (for [num nums] …​), the [num nums] part defines the binding. The body will be executed four times. On the first iteration, the first value in nums, 1, is bound to num; on the second iteration, 2 is bound to num, and so on.

In the body, we multiply num by 10. Let’s put (* num 10) in the loop body as shown:

Here is how for works: on the first iteration, num is 1 and the body returns 10. for collects this into a sequence. On the next iteration, num is 2 and the body returns 20, which is added to the sequence. This continues until all elements are processed, and for returns the final sequence: (10 20 30 40).

Now let’s use for with multiple sequences. Type and execute the following program:

Output

In this expression:

we define a vector of four colors called colors. Similarly, in this expression:

we define a vector of four shapes called shapes. Now we can use for to combine every color with every shape. Look at this:

In the code above, for iterates through each item in colors. During the first iteration, color is bound to "red", and during the last, it is bound to "yellow".

To combine these with shapes, we add another binding for shape:

It executes as follows: first, "red" is bound to color and "square" to shape. Then the body executes, concatenating them with str. Here is the complete code:

In the first iteration, "red", a space, and "square" are concatenated, and for collects "red square". Then, shape takes the next value, "circle", resulting in "red circle". This process continues for all shapes before color moves to the next value, "blue". Ultimately, for returns the following sequence:

doseq is similar to for in its iteration syntax, but it is designed for side effects and always returns nil. Look at the code below. Unlike for, it will not return a sequence of results. Use doseq when you want to perform an action without returning a value.

Output

Although doseq returns nil, you can perform actions within the loop body. For example, we can print the result of the multiplication:

Output

In a real-world scenario, this could be used to send emails to a list of recipients where no return value is needed.

Finally, let’s look at loop. Type and execute the following program:

Output

Here is how it works. First, we define the loop construct:

Now, we initialize a binding x to 1:

To print numbers from 1 to 5, we need a condition to stop the loop. We use when to check if x is less than or equal to 5:

The first part of loop is the binding [x 1], followed by the body containing the condition check:

Whenever x is less than or equal to 5, the body of the when expression is executed.

Now we add a call to println to print the current value of x:

To continue the loop, we use recur to jump back to the start of the loop with an updated value for x. We pass (recur (inc x)) as the final expression in the when block:

Now the loop starts again, but this time x is 2. Since (⇐ x 5) is still true, 2 is printed. This continues until x becomes 6, at which point (⇐ x 5) fails, and the loop terminates.

If you know in advance how many times an action needs to be repeated, you can use dotimes. Let’s look at an example.

We start with dotimes:

We pass a vector containing the counter and the number of iterations:

To repeat an action five times, we specify 5:

To use the current iteration count, we bind it to a variable, such as x:

Now we print the value of x:

Running the code above produces the following result:

In most programming languages, counting starts at 0. This is why the output begins with 0. There are five distinct numbers from 0 to 4, meaning the body was executed five times.

Here is another example:

Running this code produces the following output:

As you can see, "Hello World!" is printed five times. You might wonder why we used an underscore _ instead of a variable like x. By convention, an underscore is used when the iteration counter is not needed in the body of the loop.

Here is the code in Clojure to print Hello World:

Now, let’s make this functionality available by calling (say-hello). To do that, we use defn (short for define function):

First, we pass the function name say-hello as an argument:

Now that say-hello is passed to defn, we need to specify the arguments. Since we don’t need any arguments to print 'Hello World!', we use empty square brackets [] to indicate that no arguments are accepted.

Now, we write the function body. In this case, we simply print 'Hello World!', as shown below:

Whenever we call (say-hello), 'Hello World!' is printed. The code below shows the final version of say-hello:

Output

We can pass arguments to functions. For example, consider a function \$f(x) = x^2 + 2\$. This function accepts an argument \$x\$; if we plug in 7 for \$x\$, we get \$f(7) = 51\$. Similarly, a function in Clojure can take an argument and perform an operation with it.

Look at the say hello example below, type it, and execute it:

Output

It prints Hello Karthik !. But how does it work? By writing (defn say-hello …​), we define a function named say-hello. Notice the [name] part shown below:

The name is an argument that must be passed for the function to run. It can be used as a variable within the function body. Notice the structure of the function: it starts with defn, followed by the function name say-hello, and then the square brackets containing the argument name [name]. Now let’s finish off the function by writing its body as shown:

In the function body, we are printing a greeting to the name. We pass name to println as follows: (println "Hello" name "!").

Calling say-hello with the argument "Karthik": (say-hello "Karthik") prints Hello Karthik !. Modify the program to say hello to you.

Imagine a friend is building a billion-dollar startup with an app that helps customers calculate the area of a circle. After a successful pitch and investment round, your friend claimed that thousands of people want to calculate the area of a circle every day and that his app would be incredibly useful. He knows you are a great programmer, so you coded the circle-area function for him. The app is released, and humanity is saved.

You realize that instead of calculating the area using (* Math/PI (Math/pow radius 2)), you can simply use (* Math/PI radius radius). The latter is much simpler and easier to maintain. Consequently, all you need to do is change the code in one place, as shown below:

The rest of the app’s code is completely unaware of this change and continues to work perfectly. If you hadn’t abstracted the logic into a function and had instead placed (* Math/PI (Math/pow radius 2)) in 50 different places throughout the app, making such a change and testing it would have been incredibly difficult.

Thus, functions lead to better code and reduce the likelihood of bugs.

Functions aren’t limited to a single argument. For example, if you want to calculate the hypotenuse of a right-angled triangle with sides of lengths \$a\$ and \$b\$, it can be represented as a function \$f(a, b) = \sqrt{a^2 + b^2}\$. Now let’s code this in Clojure:

Output

In the code above, we define a function hypotenuse that takes two arguments, a and b. It should now be clear that if a function takes no arguments, the function name is followed by empty square brackets []; if it does take arguments, their names are included within those brackets, such as [a b]. In the function body, we use (Math/sqrt (+ (* a a) (* b b))) to compute and return the hypotenuse.

When we call (hypotenuse 3 4), 5.0 gets returned.

Suppose you need a function that can accept either one or two arguments. Clojure allows this through function overloading. Look at the code below:

Output

We have a function called multiple-args, defined as follows:

To allow the function to accept a single argument, we add a form as shown below:

This form:

receives one argument, arg-1:

In the function body, we print the argument using (println "One argument passed:" arg-1):

So this will respond to a function call like (multiple-args 1).

To support two arguments, we add another form with two parameters:

This is our complete function definition, which can accept either one or two arguments:

([arg-1 arg-2] (println "Two arguments passed:" arg-1 arg-2)) is executed when we call (multiple-args 1 2).

As an exercise, try writing code that allows you to call (multiple-args), which should print 'No argument passed'. If you find this difficult, refer to function_multiple_arguments_exercise.clj in the code examples.

Clojure functions can accept an unlimited number of arguments. For example, the + function can accept any number of arguments and return their sum:

Output

For a function to accept an unlimited number of arguments, prefix the last argument in the argument vector with the & symbol. Take a look at the code below:

Output

In this example, & args in the argument vector allows the unlimited-arguments function to accept any number of arguments.

For example, if we call the function like this:

We get the output Arguments: (1), which is generated by this statement:

In the previous snippet, we simply printed the arguments. In the next snippet:

We print the type of args, which is clojure.lang.ArraySeq (a type of sequence). Similarly, when we call:

All arguments— 1, 17, true, "Karthik", and :coder—are bundled into args as a sequence, as seen in the output: Arguments: (1 17 true Karthik :coder).

To define a function that accepts one or more arguments, you can write it like this:

Output

In the argument vector [first-arg & args], the first argument is captured by first-arg, and any subsequent arguments are bundled into args.

In the following example, the unlimited-arguments function requires a minimum of two arguments:

Output

The first argument is captured by first-arg, the second by second-arg, and any additional arguments are bundled as a sequence in args.

Consider a mathematical function, such as \$f(x) = x^2 + 2\$. If you plug in a value, say \$x = 7\$, the function returns 51. Similarly, you expect a programming function to return a value.

In Clojure, the result of the last expression executed by a function is its return value. Take, for example, the code below:

Output

In the code above, the result of (+ a b) is returned from the add function. Since (+ a b) is the last expression in the add function, its result is returned, captured by println, and then printed. You might have noticed nil in the output. This is because println, after printing 5, returns nil, which is then printed by the REPL.

Another clear example is any built-in math function in Clojure, such as +:

This returns 15. If you try this in the REPL, you will see 15 rather than nil because the expression evaluates to a value. In Clojure, nil represents the absence of a value or 'nothingness'.

Let’s write a function to see how the return value is determined. Try executing the following example:

Output

In the do-math function, the first expression is (+ a b). When (do-math 5 3) is called, (+ a b) evaluates to 8, but this result is discarded. The last expression is (* a b), which returns 15; this is the final return value of do-math and the value that appears in the output.

Now, let’s define another function by swapping the * and + operators, as shown below:

Output

In the code above, since (+ a b) is the last expression, its result is returned, and the result of (* a b) is discarded.

The key takeaway is that the result of the last expression in a function is what gets returned.

A function calling itself is known as recursion. For example, look at the code below:

Output

When this function is executed, it prints numbers from 5 down to 1 and then stops. We called the function like this: (count-down 5). Let’s analyze the function body:

First, the expression (println number) prints 5, and then the execution moves to the following form:

In the code above, (dec number) evaluates to 4. Since 4 is positive, (pos? 4) is true, and the expression (count-down (dec number)) is executed, resulting in a call to (count-down 4). That is, the function count-down calls itself.

This process continues until number becomes 0. At that point, (dec number) is -1, making (pos? -1) false. Consequently, (count-down (dec number)) is not executed, and the recursion terminates.

You can perform recursion by calling the function by name, as seen in the previous example, or by using the recur special form, as shown below:

Output

In the example above, we replaced the function name count-down with recur when the function calls itself. Using recur is more memory-efficient because it performs tail-call optimization. For recur to work, it must be the last expression executed in the function.

In the following example, we use recursion to compute the sum of a sequence of numbers. Try executing the code below, and we will analyze its execution shortly.

Output

In the previous example, we called (sum [1 2 3 4 5] 0), which returned 15. To simplify the analysis, let’s use a smaller example:

So, what happens when the above code is executed? Let’s look at the body of sum:

(empty? [1 2]) evaluates to false, so the following expression is executed:

Substituting the values, we get:

This can be reduced to:

Which simplifies to:

Since recur calls the current function, we can represent this as:

Now, sum is called with numbers as [2] and total as 1. Since (empty? [2]) is again false, we reach the following expression:

Substituting the values, we get:

Reducing the expression, we get:

Replacing recur with sum and simplifying (+ 1 2) to 3, we get:

Now numbers is [] and total is 3. Let’s plug these into the function:

Here, (empty? numbers) is true, so total is returned. Thus, 3 is returned, which is the sum of the vector [1 2].

What if you want a function that takes only a sequence and computes its sum without requiring an initial total? See the example below: