If Clojure data structures are immutable, then what makes it memory efficient?

Question

In Clojure, if the data structures are immutable, then it means that it returns a new variable if we apply try to change the data.

Now, this new variable will take up some memory.

How is such an architecture an efficient one?

For example, if I am changing a value of a variable inside a loop, then it will create many variables (new one per iteration of the loop) and the thread's stack might overflow.

Answer 1

When a Clojure Var is rebound to a new value, it no longer references the old value. If there are no other references to the old value, it will become eligible for garbage collection.

There are many Clojure functions which accept a collection value and return a new derived value:

(def xs [:a :b :c])
(def ys (conj xs :d))     ; => [:a :b :c :d]

Rather than naïvely copy the contents of xs to build ys, Clojure uses persistent data structures to build the values incrementally. This technique employs data sharing to enable efficient creation of new values (in terms of both memory and time), while preserving old values.