Clojure Notes 1

Posted on: Tue 19 February 2019

Started learning another general purpose programming language called Clojure which speaks lisp dialect and runs on top of JVM. Thanks to Kamalavelan for creating an interest for me to learn clojure and particularly the book titled, Clojure For The Brave and True by David Higginbotham is very enjoyable. https://nostarch.com/clojure As a matter of taking notes of what I learn from the book, I share the notes here chapter wise.

Chapter 1

Installing Clojure.
Installing leiningen.
lein new app <folder-name>
() based syntax, namespaces, -main function, println
lein run => to build and see the output
lein uberjar => to build standalone jars
lein repl => to start a repl

Chapter 2 - Emacs

I have largely ignored emacs tutorial.
But installed gnu emacs.
Downloaded clojure configuration for emacs
Downloaded and installed Nightcode IDE for clojure and I prefer it for now.
Also using lein repl to practice.

Chapter 3 - Language Fundamentals

started using NightCode with REPL.
FORMS are expressions that clojure evaluates to produce a value.
ex: 1 "a string" ["a" "string" "vector]
basic syntax: (operator operand1 operand2 ... operandn)
the above syntax is unifrom throughout LISP dialect.
(str "string1" "string2) => string1string2 => concatenates strings.
control flow => if do when
(if boolean-form then-form optional-else-form)
```
(if true
"Sucess"
"Failure")
```

note that if..else can execute only one form. to overcome this we can use do.

(if true
    (do (println "Success")
        "succesS")
    (do (println "Failure")
        "failure"))

when operator is like both if and do together but without else part and returns nil when the condition is false.
or and and boolean operators.
nil represents no value in clojure.
binding value to variables are done using def keyword
```
(def name "prasanna")
```
ratio can be directly represented in clojure. 1/5

Maps are key, value store. Hashmap and Sorted maps are present in clojure.

(def sampleMap {:first_name "Prasanna" :last_name "Venkadesh})
(get sampleMap :first_name)
(sampleMap :first_name)
(:first_name sampleMap)

(def sampleHashMap (hashmap :a 1 :b 2))

Maps can also be nested and get-in function is used to retreive nested map values.
```
(get-in {:a 0 :b {:c "1}} [:b :c])
```

Vectors are like 0 indexed arrays and can be heterogenous.

[1 2 3 4]
(def vecData [1 2 3 4])
(get vecData 2)
(conj vecData 10)

conj function is used to append value at to vector and vector function is used to create a new vector with supplied values.
```
(vector "test" 1 "testing")
```
list in clojure is similar to vector, but get function will not work with list. nth function has to be used instead.
```
'(1 2 3 4)
(list 1 2 3 4)
(def listData '(1 2 3 4))
(def listData (list 1 2 3 4))
(nth listData 0)
```
conj function with list will add elements to the beginning of the list.
```
(conj listData 10)
```
Fetching elements from list using nth function will be slower than get in vector. When to use what depends on whether we want to add elements to end or beginning of the data structure.
Clojure supports higher-order functions, i.e a function that can take another function as argument or can return another function. Programming languages with higher-order functions are said to support first class functions because we can treat functions as values in the same way we treat other data types like number, string, etc.,
inc function can increment a numeric value. map function can operate over a collection and can return a list as result.
```
(inc 20)
(map inc [1 2 3 4])
```
[] is used to pass arguments to functions. function parameters can be used to overload and can be used for multiple purposes. Those are called Arity.
```
(defn myFunction
  ([]
    (println "no arguments supplied"))
  ([x, y])
    (println "two arguments supplied"))
)
```

& ampresand is used to denote rest of parameters. Like *args in python

(defn myFunction
  [name]

(str "Hi. I am " name))

(defn myFunc
  [& names]
  (map myFunc names))

(myFunc "Prasanna" "Kamal")

Anonymous Functions are functions without names. They can be defined anywhere using fn keyword.

(fn [arguments] function-body)

((fn [x] (* x 3)) 8)

(map (fn [name] (str "Hi " name) ["Prasanna" "Kamal"])

anonymous functions can also be bound to variables.

(def my-function (fn [name] (str "Hi, " name)))
(my-function "Prasanna")

There is a much more shortcut way to define anonymous functions using #.
```
#(+ % 2)
(#(+ % 2) 8)
(#(str "Hi " %) "Prasanna")
```
If the anonymous function takes multiple arguments, then %1 %2 ... %n form can be used.

Destructuring is about binding names to values in a collection based on positions.

(defn chooser
  [[first-param]]
  first-param)

(chooser ["Prasanna" "Kamal"])

(defn chooser
  [[name age & other]]
  (println (str "Hi, " name))
  (println (str "Your age: " age))
  (prinln (str "Other info: " (clojure.string/join ", " other))))

(chooser ["Prasanna" 28 "test@testing.org" "B+"])

Clojure has closures. Yes. closures are those functions that are returned by another functions. closure by itself is a design pattern to indicate state maintanence or scope of variables. To be frank, I haven't grasped this design well yet.
```
(defn inc-maker
  "Create a custom incrementor"
  [inc-by]
  #(+ % inc-by))

(def inc3 (inc-maker 3))

(inc3 7)
```

End of Chapter 3. Will continue further notes in separate post.

Category: Programming – Tags: books, code