How does argument passing work in Clojure?

Question

I know that in Java, if I pass an object to a method as an argument, then the method will let the argument variable point to the same object rather than making a duplicate. How about in Clojure? For example:

(defn print-from-reader [rdr]
   (print (.read rdr)))

(...inside some code...
  (with-open [rdr (Reader file)]
    (print-from-rader rdr)))

Does print-from-reader make another copy of rdr in memory when rdr is passed in, or it's pointing to the same rdr that's already created by with-open binding?

And is there any way to check if two clojure instances are pointing to same memory?

Sorry about my bad terms such as "pointing to" and "instances", I am a newbie in Clojure and still learning it. :-)

Answer 1

According to answer to this question on google groups it's pass by value.

Clojure inherits the argument-passing semantics from Java. So it is pass-by-value, where the value passed is an object reference. In addition there are optimization facilities that enable the passing of primitive-typed values.

So functions don't make copies when parameters are passed. rdr in your code will be the same instance.

Makes sense to implement it like that due to java interoperability - otherwise you couldn't (easily) modify java objects' state with its method.

You can test it easily:

(import 'java.util.HashMap)
(def m (new HashMap))
(defn foo [m] (defn bar [m] (.put m "testkey" "testvalue")) (bar m) (println (get m "testkey")))

(foo m)

Results in :

testvalue
nil

If bar created its own copy of m, then the println wouldn't print the value assigned inside bar.

Answer 2

Clojure is pass-by-value just like Java. I think of it as, the references are passed by value. It isn't a stretch for Clojure to work like this, Scheme and Common Lisp behave the same way.

You can test whether two references point to the same memory with identical?:

(identical? x y)

Tests if 2 arguments are the same object