Clojure Course - Syntax and Data Types

Clojure Course

Part 2 - Syntax and Data Types

Homoiconicity

If you have seen a couple of the mainstream languages, you realize that they all have pretty similar syntax: variable declarations, loops, conditions, functions, classes... Because they all have their origin in the C language.

But Clojure is different, because it is rooted in the ancient and arcane technology of LISP! Clojure code is organized in lists, marked by (parentheses). The first element of the list is the function position that Clojure tries to invoke. The rest of the elements are the parameters. Multiple parameters are separated by whitespace. Comma is also treated as whitespace, you can use it, but it is ignored anyway.

In the first example, the println function is executed, printing all its arguments to the output. nil is the return value of the function, just ignore it for now.

(println "Hello" "world" 4 "ever")

Clojure programs are written as a bunch of nested lists. The fancy word homoiconic means that Clojure code is expressed by its own data structures (lists). This will be more important later when we deal with macros... for now, just focus on the lists.

Operators

You can do simple math with the + - * / operators. These are actually functions, and all of them can take more than 2 arguments. There are no "infix" operators in Clojure, the function call is always written as first in the expression.

(- (* 8 (+ 1 2 3)) 1 5)

The code is evaluated starting from the deepest level of nesting. So the previous example is calculated in this order:

(+ 1 2 3) => 6 (read as 1+2+3)
(* 8 6) => 48 (read as 8*6)
(- 48 1 5) => 42 (read as 48-1-5)

Literals

The various building blocks you will encounter in Clojure language:

Integer numbers 0 7 -24 599999
Floating point numbers 3.14159 0.0000001
Fractions 3/4 22/7 - they won't work in these snippets because of the Javascript involved, but they work fine in JVM, Clojure can calculate normally with ratios.
Strings "Clojure" "is" "cool" - enclosed in double quotes
Characters \a \P \7 - single char, prefixed with a backslash
Booleans true false
Null or None type nil - represents the absence of a value
Keywords :name :ip-address - begin with a colon, they are like variables that have no value, just a name. They are useful as keys in hash-maps, or as enums.
Symbols filter + pos? swap! - they are references to any object, like a number, a function, a data structure, or an expression. In other languages you might call them variables, but in Clojure, most things are immutable... so we call them symbols. Apart from letters and numbers, some special characters are allowed: * + ! - _ ' ? < > =. Predicate functions that evaluate to true or false, usually have a question mark in them. Impure functions, which modify external state outside the function, usually have an exclamation mark.

Collections

Clojure supports four basic types of collections. They are immutable and extremely efficient. They can contain heterogenous data (different types of values and even nil values).

List: a singly linked list. Note that the list (as a container of data) is in round parens, but it is prefixed with an apostrophe (quote) character. This prevents Clojure from executing it as a function call.

'("Batman" "Superman" "Spiderman")

Vector: a sequence of indexed values, similar to an array, in square brackets.

[2 3 5 7 11 13 17 19]

Set: a collection of unique values, enclosed in curly braces prefixed with a hash sign.

#{true :magic nil "Wizard" 42}

Map: a list of key-value pairs, enclosed in curly braces. Similar to a Python dictionary, or a JSON object.

{:first-name "Vito" :last-name "Corleone"}

All of these collections respond to the sequence interface, so they are highly compatible with each other, but each of them has some unique traits and built-in functions. They can be deeply nested too:

'({:pokemon ["Pikachu" "Eevee" "Snorlax"]
:smurf ["Papa Smurf" "Hefty Smurf" "Smurfette"]
:shrek-character ["Shrek" "Fiona" "Donkey"]}
{:icecream-flavors #{"vanilla" "chocolate" "pistacchio"}})

We'll learn more about collections later, they are really important tools to support the functional programming paradigm. In the next part we will look at functions and control structures.

[Clojure] 02 Syntax and Data Types