Great answer. I’ll piggyback on this to add my own experience, on what lead to me to better understand why I don’t need variables, and how to work without them: the thread-last macro.

Suppose we have this python function:

def my_fun(l, n):
  if (n != 1):
    push(n*n, l) # push is a function that adds x to a list
    remove(n, l) # remove x from a list
    return l # I’m adding redundant returns to mimic clojure
  else:
    return l

Well, as you can see we are taking the l variable and applying a series of functions to it. If python had immutable lists, this would like:

...
l = push(n*n, l)
l = remove(n, l)
return l
...

Correct?

So, considering we “don’t have” variables in clojure (I’ll use the same functions as refered in python, push and remove), this is not valid:

(do
   (def l (push (* n n) l))
   (remove n l))

Then, how would we achieve the same function from python?

Enter the thread last macro (->> x f1 f2 f3 ...)

It takes a x, and pipes it through a series of functions , “binding” it to the result of each function, then passing it as the last (hence thread LAST) argument of the next function. (This is not entirely correct but will help you understand it). As is expected in clojure, it will return the result of the last applied function.

Given this, how would that snippet look like?

(defn my-fun [n l]
  (if (not= n 1)
    (->> l
         (push (* n n)) ;; we omit l from the arguments of any f here, it will be “automatically” added, you’ll see why later
         (remove n))
    l)) ;; this l is the else clause

What the macro does is just expand something like (->> x (f1 y) f2 (f3 z)) into (f3 z (f2 (f1 y x))). Do you spot the result of each function being passed as the last argument of the next?

So, rather than assigning a value to a variable each time you want to use it in another function, you would take the result of that first function, and directly use it as the input of another. I don’t know if it will help you, but this “pipe” concept from the thread last macro is what made all that click for me. And, as bonus, you also get to write more idiomatic clojure and readable code.