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 OS platforms, you can install Clojure following the link here https://clojure.org/guides/install_clojure. Once done it’s time for us to check the Clojure REPL. To know what is REPL, checkout https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop. Type clj in your terminal, and you must get 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 the Hello World, don’t worry much about that, we will see what is that later. After the nil you see once again user⇒ which means Cloure is waiting for your type another command for it to execute.

If you want to come out of this Clojure REPL, type CTRL+D. You will get back to normal GNU/Linux prompt.

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

Press CTRL+D and it should stop. All is well, and you have installed Leiningen.

Open or create a file ~/.lein/profiles.clj and add this:

in it.

When I first started to study Clojure, I was introduced to REPL driven development. I did not get it what it was during my early day, even if you don’t get it, worry not, you will eventually get it. In this let’s get a taste of REPL driven development.

First let’s print Hello World!, copy the stuff below, paste it and execute it:

Output

So you get Hello World! as well as a nil printed in the next line. Forget about the nil, we will look into it when we see functions, but our mission is accomplished.

Commenting is very essential in coding. Comments are nothing but notes for the developer who is reading the code, while executing the code, the computer will ignore comments. In Clojure everything that follows after semicolon ; is a comment. So in the code below:

Output

; Says Hello to this world is a comment which the Clojure interpreter will ignore. In the code above, we are commenting in the same line as there is code, usually it’s a convention to use just one semicolon ; for such things. If you want an entire line dedicated for comment, we use two semicolons ;; as shown below:

Output

Both single and double semicolons makes no difference, but that’s the way conventions have evolved in Clojure for commenting after a piece of code and dedicating a whole line for comment.

We have printed Hello World, but then what if we want to print something else with it. With println its simple, just give other stuff too, and it will print as shown:

Output

So you have successfully printed something in Clojure.

In this section let’s see about Math in Clojure. First let’s add two numbers 40 and 2, it’s been done as shown:

Output

In the above thing we have the plus + sign (it’s actually a function in Clojure), and we pass 40 and 2 to it for it to add and return 42. Similarly let’s see what will happen when we pass 44 and 2 to minus - sign:

Output

It seems to subtract the second argument 2 from 44 and returns 42.

Now let’s see what happens when we pass 6 and 7 to asterisk * or a star:

Output

We see it returns 42, which is a multiple of 6 and 7.

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

Output

Looks like 210 is divided by 5, and we get 42.

Now let’s see what will happen if we pass more than 2 numbers to plus +:

Output

All are added and the result of addition is got.

Now look at the code below, can you figure out how it works?

Output

Let’s take the code (/ (+ 1 2 3 4 5) 5), concentrate on the innermost braces (+ 1 2 3 4 5), here a bunch of numbers are passed to ` and we should get the sum of 1 to 5, that is 15 returned. So in place of `( 1 2 3 4 5) let’s substitute 15, so we get an expression like this (/ 15 5), which is nothing but 15 and 5 are passed to /, which means 15 divided by 5, and hence we get 3.

Now let’s pass one or more argument to /, passing 1, 2 and 3 to it, we get \$1/6\$ as output as shown below:

Output

The above output is a fraction, to get a decimal output of a division, append a .0 to the number when passing to /

Output

It’s enough to know that any one number that’s been passed to / has a decimal value that is point . something appended to it, we will still get decimal rather than a fraction as output as shown below:

Output

Same is the case below too:

Output

Now if we need to get quotient of a division, we can pass numbers to a function named quot as shown:

Output

To get reminder of a division operation, pass numbers to rem function as shown:

Output

Let’s now try to find out area of a circle using Clojure. We know the area is \$pi r^2\$, where \$pi\$ is roughly \$22/7\$. So let’s see how to code it. Look at the code below:

Output

Here we represent \$pi\$ by (/ 22 7) the \$r^2\$ where \$r\$ 7 is (* 7 7), this is multiplied with (/ 22 7) and we get (* (/ 22 7) (* 7 7)). Now the output we got is 154N.

If I add a .0 to any number below, the N disappears:

Output

Rather than coding our own \$pi\$ as (/ 22 7), since Clojure is built on Java, we can tap into Java Math library (https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html), and use its methods. This is one advantage of Clojure, since it’s a hosted language, it can take advantage of libraries provided by the host platform. So we replace (/ 22 7) with Math/PI as shown below:

Output

Similarly to compute \$x^y\$, we can use Math/pow so instead of (* 7 7), we can replace it with (Math/pow 7 2) as shown below:

Output

There are different types of numbers in computing just like there are different types of numbers in Mathematics. For example whole numbers are called as Long in Clojure. You can verify it by passing a whole number to a function named type which tells the type of data been passes to it as shown below:

Output

The numbers with decimal value are called as Double in Clojure as you can see below:

Output

The value of \$pi\$ too is a double in Clojure:

Output

If two whole numbers or Long divides another Long, what you get is a Ratio in Clojure:

Output

As you can see below \$84 / 32\$ in Clojure does not provide a decimal value, but outputs a Ratio:

Output

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

Output

But you can convert it to double by passing it to a double function as shown:

Output

When querying about its type, it does say Double:

Output

Say you don’t want a division of two Long’s to give you a Ratio as output, to prevent it, convert any one of the number that’s been passed to / function into a Double as shown below:

Output

The output you get is a Double and not a Ratio:

Output

If you want to just get a non-decimal part of a Double, pass that double to long function as shown:

Output

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

Output

In this book I think your very first Clojure program would have been this:

It prints Hello World on the screen. The "Hello World!" which is enclosed by double quotes " is nothing but a string of characters and hence it’s called a string.

Anything that’s enclosed by double quotes in Clojure is a String as you can see below:

Output

Strings can be joined with even non String things using str function as shown:

Output

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

You can get the character count in a string using the count function as shown below:

Output

In the code below, to str function we are passing 6 arguments. The first five are numbers, and the last one is a string " and so on…​":

Output

You can see how Clojure neatly concatenates them and returns out a string.

Clojure has an inbuilt String library, you can read its documentation here https://clojuredocs.org/clojure.string. From it let’s use the function reverse to reverse a String:

Output

Now lets covert all characters to upper case:

Output

I hope this section has briefly explained something about strings. You will learn more as you go by. Hang on…​.

Imagine variables as boxes containing some value, this can then be used in code to make it more human readable. For example look at the code below:

Output

I have assigned String "Karthik" to a variable named my-name, now I can use this my-name any where in the Clojure code. If you look at creation of a variable, you can see these three things, first is of course empty braces:

Then we have the def function:

Following the def we have the variable name, in this case its my-name:

As a second argument to def, we give the value that needs to be stored in my-name that is "Karthik" in this case:

So that is how we define a variable. Usually the variable defined with def is called a global variable, that it is available anywhere in the program. If it doesn’t make sense now, don’t worry.

Now we can print this variable as shown:

Output

Over here I am adding "Hello" before the variable my-name and its as equivalent as using string "Karthik":

Output

Look at the code below:

Output

I am having a variable called greeting defined above, and it’s been assigned the result of (str "Hello " my-name "!"). That is three strings "Hello ", my-name and "!" are joined together, and the result is stored in greeting. Finally, we print it using (println greeting).

Variables like my-name and greeting can be used anywhere in code, because they are defined using def keyword. If you want a localized variable inside a code block (), you can use let to define it as shown:

Output

In the above code, we define a variable named local-variable to be "something", and we successfully print it, but outside the bounding braces (let …​), this local variable fails to exist as you can see from the code below:

Output

Trying to print local-variable results in an error.

Till now, you might have run your code on REPL, either in your terminal or in your IDE, possibly VSCodium. Now let’s see how to store your code in a file and run it. First type the following name in a text editor:

Save the code as hello_world.clj, in your terminal cd to that directory, then type this in terminal:

The entire program will run, and you will see Hello World as output. I got this as output:

Imagine racks with a lot of compartments in it, the first compartment is labelled 0, the second 1 and so on. You can put something into this rack and get it back if you know the rack number aka the index. This is a kind of real world analog to vectors.

Look at the code below:

Output

This is how you represent a vector in Clojure. It starts with an opening square braces [ and ends with a closing one ], and anything in between are the elements of the vector. In the above code you got 4 elements namely 1, 2, 3 and 4.

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

Output

In the above code we have passed 1, 2 and 3 to the function vector, and we have got out a vector [1 2 3].

Till now, we have seen creating vectors with numbers, in reality you can create vector with any type of value:

Output

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

In the code below, we are defining a variable named friends and we are assigning a vector that contains four names to it:

Output

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

Output

And we get the first element in 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 see "Ram" is ignored as it’s the first element and the rest is returned.

Let’s check the type of friends

Output

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

Output

Though it seems to return ("Bashir" "Antony" "Buddha"), which are not enclosed in square braces, on querying the type, it seems to be a chunk 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 second should be the index number as shown:

Output

If you see, at index 3 of friends is a String "Buddha".

The third index can also be access like shown:

Output

Doesn’t it look like when you did (def friends <a vector>), Clojure seems to have constructed a function called friends which can take a number, and the value at the index gets returned?

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

Output

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

Output

and it still shows the old values without "Periyaar", in reality Clojure constructs a new vector when we say (conj friends "Periyaar") and returns it out.

To add an element before a vector, use cons as shown below:

Output

Does it modify friends? Now research what is immutability ^[4] in computing.

Lists are just like vectors, now all you need to remember is a vector is set of things wrapped between square brackets [ and ], a list is wrapped between round brackets ( and ). In fact entire Clojure program is a list. Remember how we calculate \$3 + 5\$ in Clojure, it’s like this (+ 3 5), it’s wrapped in round braces, and hence it’s a list.

Entire Clojure code is nothing but a list. It has an open braces (, and a function to call. To add we use the ` function, and so we have `(, this is followed by arguments that are passed to the function, so to add 3 with 5, we pass the arguments to function like this (+ 3 5, then this is followed by closing round braces (+ 3 5), thus completing the list, which could be executed by the Clojure interpreter.

Take a look at the example below:

Output

In the example above, we build a list of 4 numbers. But notice that we don’t start with a (, but we start with an apostrophe followed by bracket like this '(. This is to tell Clojure that not to execute the content in the bracket.

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

Output

So the apostrophe before the round brackets is to tell the Clojure not to execute '(1 2 3 4), but just treat it as a list.

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

Output

Above we pass 1, 2, and 3 to the list method, and we get a list returned.

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

Output

Note how I am 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 there in friends-list. For that we use count as shown below and pass friends-list to it.

Output

So count say there are four elements in friends-list.

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

Output

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

Output

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

Output

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

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

Output

and, it fails.

Now, let’s add an element to the list. For that we use method called conj, to conj, we will pass the list to which the element should be appended, followed by the element which needs to appended to the list as shown below:

Output

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

Output

A set starts with a hash and curly braces { followed by set items {1 2 3 4, then it closes with a curly brace #{1 2 3 4}.

Below we query the type of set:

Output

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

Output

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

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

Output

Once again we 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 ash shown below:

Output

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

Output

It returns true since fruits does contain "Banana".

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

Output

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

You can also check if a set contains an element as shown below:

Output

In the code above we pass "Banana" to fruits and it returns "Banana" since "Banana" is in fruits.

When we pass "Jack Fruit" to fruits, it returns a nil or nothing since "Jack Fruit" is not in fruits:

Output

Now let’s see if fruits contains "Banana" by passing fruits to "Banana" as shown below:

Output

It fails.

There is a thing called keywords in Clojure. Their syntax is colon followed by some stuff :<some-stuff>, say if we want a set of programming languages, we can define it as shown below:

Output

Here 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 see if an element exists in programming-languages by passing that element to it:

Output

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

:ruby is a keyword, so it has some special properties compared to string. If you remember checking if "Banana" exists in fruits using the code ("Banana" fruits) fails, but checking if :ruby exists in programming-languages will work as shown below:

Output

We can add an element to a set using the function conj, followed by the set programming-languages in this case and let’s add :perl to it:

Output

We can remove an element from a set using the function disj, followed by the set programming-languages in this case and let’s remove :python:

Output

So that’s it about set’s for now.

Lists and vectors can be accessed with numeric index, say in the below code:

Output

We get "five" as output. But what if we want something user-friendly words as index for our data collection? Enter the world of maps.

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

Output

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

Rather than using curly brackets, we can create a map by passing keys and values to a function called hash map as shown below:

Output

The function hash-map receives keys as odd arguments and values as even arguments. So in the code above "name" is mapped to "Bashir" and key "age" is mapped to value 20.

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

Output

Now we get "name" of friend using the get method to which we first pass the map and the second argument is the key to be fetched.

Output

So the code above looks for key "name" in friend, its corresponding value is "Bashir" which gets returned out.

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

Output

So the example above we have map friend, and to it, we are passing the key "name", and it returns the mapped value "Bashir".

Now the type of "name" is string as you can see below:

Output

There is another thing called keyword, that is preceded by a colon : followed by the name of the keyword. So as you see below :name is a keyword:

Output

Now rather using strings as key’s, let’s create a map with keywords as keys as shown:

Output

In the code above, we create a map with key :name, which is mapped to "Periyaar"; and key :age is mapped to 20. We assign it to wise-friend.

Now we can get the :name of wise-friend as shown:

Output

We can get :age of wise-friend as shown below:

Output

In the above example e use get function, to it the map is passed as the first argument, and key is passed as the second argument.

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

Output

We get Periyaar is very wise.nil printed out. Replace print with println in the example above. What do you observe?

Since we use keywords as keys in wise-friend, getting value of a key is possible as shown:

Output

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

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

Output

In the code above we have the assoc function, which we can call associate. To it we pass the map wise-friend, then we pass the key :belief and value "Rationalism" to it. In Clojure, things are immutable. The above operation returned a new map {:name "Periyaar", :age 90, :belief "Rationalism"}, and since we did not define it to any variable it’s just lost. One might not think wise-friend got a new key and value. In fact if you query wise-friend for :belief, it would say nothing is there:

Output

All old values of wise-friend are still 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 and we get an output map containing only the :name. Once again you must not think Clojure changed wise-friend. dissoc (or disassociate) took wise-friend as first argument, and key to be removed as second, and it created a new map without the passed key and returned it. In Clojure things don’t mutate.

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

Output

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

Output

wise-friend has key :name which is of type keyword, "name" is of type string. So you can have a array with keyword and string spelled the same. As you see below:

Output

By adding "name" as key and associating a value "Ramasamy" to it, we are creating a map with keys :name and "name". though such kind of tricks are possible, it’s highly discouraged for the sake of clarity in code.

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, to it, you pass any valid function name. Below we pass + to doc and its documentation gets printed:

Output

From the above documentation I know + can receive no argument and might return a zero:

Output

Which seems to be true as shown above. I also infer + receives a single argument and returns the number:

Output

Which also seems to be true. Then I infer + receives a two or more arguments and returns its sum, which also is verified in the code below:

Output

Output

If you want to search the entire Clojure documentation text, you can use the find-doc method 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 name contain certain piece of string, use the apropos function as shown below:

Output

Above, I have used the apropos function to find all functions whose name contains the string "replace". Now below I check the documentation of the function replace to reveal what it does:

Output

If one is not comfortable to use Clojure REPL to access documentation, one may use Clojure’s online documentation which is available on https://clojuredocs.org/

If you see the image below, I have searched for reduce, and it shows all functions who names have the word reduce in them.

I clicked on reduce and below you can see that Clojure shows documentation for it:

Clojure docs is a convenient way access documentation on the 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 make your code execute according to it. Welcome to cond or condition. Take a look at the program below and execute it:

Output

It prints 5 is positive. That’s because we have set number as 5 in let [number 5]. Then the cond form is coded like this:

In the above piece of code, when number is greater than 0, it satisfies the condition (> number 0) and the code next to it (println number "is positive.") gets executed.

Change number to negative and execute it, see what happens and explain it. When no condition is satisfied the else part:

gets executed. Make number as 0 and execute it, see what happens.

Execute the code below and explain it to yourself.

Make number as 0 execute it and see 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 check the value of num, num is not 1, so the statement 1 "one" is not touched.

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

So finally the else part "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 loop we are going to see if for, type the code below and execute it:

Output

Let’s see how it works. So,

assigns [1 2 3 4] to nums. Then we invoke the for as shown:

In the above code for [num nums] is the new addition, so the loop body in the above code will be executed 4 times, the first time it gets executed, the first value in nums that is 1 will be loaded into num, the second time it will be 2 and so on.

So in the loop body all we do is to multiply num by 10, so let’s put (* num 10) in the loop body as shown:

So what for does is this, first time num is 1 and the loop body returns (* num 10) which is 10, so for creates a list with (10). The next time num is 2 and (* num 10) is 20 which get returned and for now has a list (10 20) (imagine like 20 is appended to '(10)), and so on it continues till for has a list (10 20 30 40), finally for returns it.

Now let’s try out a for program with multiple sequences. Type the program below and execute it:

Output

So in this statement:

We assign four colors to a variable named colors. Similarly, in this statement:

We assign four shapes to shapes. Now let’s use for to combine all colors with all shapes. Now look at this:

So in the code above we tell the for to execute each time for every item in colors, the first time it executes color will be the first value of colors, that is "red", the last time it executes color will be the last value of colors that is "yellow".

Now we need to mix in shapes, so we just load every shape in shapes into a variable called shape as shown:

The way it executes is like this, first "red" gets loaded into color, then "square" gets loaded into shape, the loop body gets executed, here the loop body is simply concatenating color and shape using str, so let’s add (str color " " shape) to our code below as the body of for loop.

So the first time "red", then a space " " and "square" gets stringed together and for has a collection ("red square"), now the next time, the shape takes the next value in shapes, that is "circle", and we get "red circle" as the output of (str color " " shape), and hence for has the collection ("red square" "red circle"). This goes on till all values in shapes are iterated, and now color takes on the next color that is "blue", and the process continues. Ultimately for will return this list out:

doseq works just like for, but it returns nothing. Checkout the code below, if you think it will return (10 20 30 40), you are wrong. When you want something to be executed, but then nothing should be returned, then doseq is the thing to be used.

Output

Now check out the code below, though doseq returns nothing, you can make it do something in the loop body, here we just print numbers multiplied by 10:

Output

In real world it could be a code to send emails to n-number of people or something like that where there is no need to return anything after the loop has run.

The final loop we are going to see in Clojure is loop, type the program below and execute:

Output

It works like this, first you have a function loop:

now let’s initialize a variable named x to 1:

We want to print from 1 to 5, then the loop should check the condition if x is less than or equal to 5, so let’s check the condition (⇐ x 5) using a function called when:

So the first argument to loop is [x 1], the second one is the condition check:

So when ever x is less than 5 (⇐ x 5) what ever is put in (when (⇐ x 5) …​) gets executed.

Now let’s have a simple loop body to print x, so we get:

We need to the loop to continue once it has printed x, so for that we call a function recur with updated value of x, let’s pass (recur (inc x)) as second argument to when as shown:

So now once again loop is hit, but now x is 2 this time, and still (⇐ x 5) passes, now 2 gets printed out, it goes on and on till x is 6 and so (⇐ x 5) fails, and the loop stops recurring and execution stops.

So this is the code in Clojure is to print Hello World:

Now I want to make this same functionality available by calling just (say-hello). To do that I first call a function called defn or define function

To it, as a first argument I pass the function name say-hello:

Now say-hello is passed to defn, but since say-hello is defined as a function, we can accept arguments for it, but here we need no arguments as we are going to print Hello World!, so lets put empty square braces as no arguments will be accepted by say-hello

Now all we need to do is to write the function body, in the body we print hello world as shown below:

So when ever we call (say-hello), Hello World! gets printed. Below code shows the final version of say-hello:

Output

We can pass arguments to functions, say we have a function \$f(x) = x^2 + 2\$, this function accepts an argument \$x\$, now we plug in 7 to \$x\$, then \$f(7) = 51\$. In the same way, a function in Clojure can take in argument and do something with it.

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

Output

It prints Hello Karthik !, so how it works? By typing (defn say-hello …​), we define a function named say-hello, after that notice the [name] as shown below:

The name is an argument you need to pass for the function to run. It can be used as variable in the function. Notice how the function is structured, you have the defn, followed by the function name say-hello, then there the square bracket containing the single argument name [name]. Now let’s finish off the function by writing its body as shown:

In the function body, we are just printing saying hello to the name, we pass name to println like this: (println "Hello" name "!").

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

Say your friend is coding a billion-dollar startup that lets its customers find circle area using an app. Your friend had a successful pitch and investment round where he claimed that 1000s of people wanted to find circle area every day and his app will be useful for it. He knows you area great programmer, and you coded the circle-area function for him. The app releases and humanity is saved.

You find that rather than finding circle area using (* Math/PI (Math/pow radius 2)), you can find it by (* Math/PI radius radius). The later is much simpler and easier to maintain. So all you need to do is to change the code in one place as shown:

The rest of the code in the app is totally unaware of this change, and works just fine. Instead of abstracting things away as a function, if you put (* Math/PI (Math/pow radius 2)) everywhere, say in 50 places in app, it would be really difficult to change and test.

So functions help in better coding, and even reduces the possibility of bugs.

It’s not that functions should have only one argument, say you want to find the hypotenuse of a right angle triangle with of sides of lengths \$a\$ and \$b\$, then it can be written as a function \$f(a, b) = sqrt { a^2 + b^2 }\$. Now let’s code this one in Clojure:

Output

In the code above, we define a function hypotenuse, and it takes in two arguments a and b, so I think it should be clear to reader now, if a function takes no arguments, the function name should be followed by empty square brackets [], or if it does then the argument(s) name(s) should be included in those square brackets like [a, b]. In the function body we just add the statement (Math/sqrt (+ (* a a) (* b b))), which computes the hypotenuse and returns it.

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

Let’s say for some reason we need a function where it can accept one argument, and the same function can also accept two arguments. We can do that too Clojure. Look at the code below:

Output

So we have a function called multiple-args, that’s defined like this

So in order to accept one argument, we add a form as shown below:

This form:

Receives one argument arg-1:

And in the body of the function we print it using (println "One argument passed:" arg-1) as shown:

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

Now in order to have two arguments, we add this another form that has two arguments in it:

So now this is our function definition which can accept one argument or two arguments:

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

As an exercise try writing code that will let you call (multiple-args), this should print out No argument passed. If you are finding it difficult refer function_multiple_arguments_exercise.clj in the code examples.

It is possible to accept unlimited number of arguments in a Clojure function. For example + function can accept unlimited number of arguments and can give us the sum:

Output

For our functions to accept unlimited number of arguments, prefix argument with an & followed by a space, take a look at the code below:

Output

In the above example we have & args, between square brackets, so the function unlimited-arguments can accept any number of arguments.

Say if we call the function like this:

Then we get the output as Arguments: (1) which is generated by this statement:

In the above code snippet we are just printing the arguments. In the below code snippet:

We are printing the type of args which seems to be clojure.lang.ArraySeq, which I think is some list. In similar fashion when we call:

All 1 17 true "Karthik" :coder, seems to be bundled in args as a list, as you can see from the output its printed as Arguments: (1 17 true Karthik :coder).

Let’s say that we want a function where it accepts one or more arguments, we can code it like this:

Output

Look at [first-arg & args], so the first argument gets captured in first-arg, the rest if they are there gets bundled up in args which is present after & inside the square braces.

In the example below, the function unlimited-arguments has to have minimum of two arguments:

Output

The first argument is caught by first-arg and the second by second-arg, the rest is bundled up as list in args.

If you think about a mathematical function, say \$f(x) = x^2 + 2\$, if you plug in a value say \$x = 7\$, it returns 51. So you expect a function to return something.

In Clojure, the last statement executed by a function returns. Take for example the code below:

Output

In the code above, the result of (+ a b) is returned out of the function add. If you see (+ a b) is the last statement of the function add. This is captured by println and is printed out. You might have noticed a nil in output, That’s because println after printing 5 returns nothing or nil and hence nil gets printed in the REPL.

Another good example will be any math function in Clojure. Take for instance the +

Returns 15, and hence if you try it out on the repl, you will get 15 and not nil, there is no nil here because it returns something. Think of nil as equivalent to nothing or emptiness in Clojure.

Now let’s code something and see what it returns. Code the example below and execute it

Output

In function do-math, you see the first form is (+ a b), when (do-math 5 3) is called, (+ a b) returns 8, but it gets thrown away and lost, the last statement is (* a b), and it returns 15, this is what gets returned from do-math and that’s what appears as output.

Now lets code another function swapping the * and + as shown:

Output

In the above code, since (+ a b) is at the last, it gets returned. What is computed by (* a b) is lost.

The moral of the story is the last statement or forms output gets returned from a function.

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

Output

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

First we have the form (println number) which prints out 5, then it comes to this form:

So in the above code (dec number) is 4 and is positive, and hence (pos? 4) is true, hence the statement (count-down (dec number)) gets executed, and so (count-down 4) is called. That is the function count-down calls itself again.

This goes on till number becomes 0 and (dec number) is -1 and hence (pos? -1) is false thus (count-down (dec number)) is never reached and the program exits.

You can call a function from itself using the function name as in the example above, or you can use recur as shown below:

Output

In the example above, we have replaced the function name count-down with recur when the function needs to call itself. It said that when we use recur it more memory efficient and the condition it must satisfy is hat recur should be the last statement executed in the function.

In the example below, we use recursion to compute the total of sequence of numbers passed to a function. Type the code below and execute it, we will see how it works soon.

Output

In the above example we have tried out sum like this (sum [1 2 3 4 5], 0), which returns 15. to simplify it let’s try out something as shown:

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

(empty? [1 2]) become false, and hance this get’s executed:

When substituting values, we get the following:

Which can be reduced to this:

and so we get:

Since recur calls the same function it’s in, we can write it as:

So now a sum is called with numbers taking tha value [2] and total taking the value 1. Once again (empty [2]) is false and we end up with:

Which on substitution we get

Now reducing it we get:

Substituting recur with sum and reducing (+ 1 2 ) to 3 we get:

So now numbers takes the value [] and total take the value 3, now let’s plug it into:

Here (empty? numbers) is true and hence total must be returned, hence 3 gets returned which is the sum of the vector [1 2].

What if you don’t want to pass the total and want a function that take a sequence and computes its sum. Take a look at the example below:

Output

In the above example we have function collection-sum that takes a collection, it abstracts away by passing the collection and initial total as 0 to the sum function which we coded before. sum uses recursion to calculate the sum.

Let’s say you pass an argument(s) to a function, based on the passed value, it’s determined which function or method is to be called. This technique is called multimethods.

Take a look at the code below, type it and execute it:

In the line (defmulti factorial identity), we tell Clojure that we are having a multimethod called factorial, the kind of execution path that factorial will take is defined by the identity passed to it. Now in the code below, we say if the identity is 0:

Then take in the argument:

We are not going to use the argument anywhere, so it’s a convention to use underscore _ for that, and we tell it to return 1:

For any other argument, we use the :default keyword:

We take in the argument as num

We return \$n um * (n um - 1)!\$ as show below:

This does the trick, and we have clean and elegant code to find factorial of any number.

Now consider the code below:

Output

The function print-welcome-message accepts person as argument, the person could be a string, a vector or map, depending on it, the program extracts data and prints it as shown in the below form:

The same thing is done using multimenthods in the code below. Type it and execute it and I will explain: