Mutable fields in Clojure deftype?

Question

I'm trying out Clojure 1.2, specifically mutable fields which are supported in deftype according to the clojure.org documentation.

But I can't get the set to work. What is the syntax for updating a field? Or isn't mutability implemented yet?

(definterface IPoint
  (getX [])
  (setX [v]))

(deftype Point [x]
  IPoint
  (getX [this] x)
  (setX [this v] (set! (.x this) v)))

user=> (def p (Point. 10))
user=> (.getX p)
10
user=> (.setX p 20)
ClassCastException: user.Point cannot be cast to compile__stub.user.Point

Using a 1.2 snapshot from a few days ago.

Nonunion

Answer 1

deftype's default is still to have the fields be immutable; to override this, you need to annotate the names of the fields which are to be mutable with appropriate metadata. Also, the syntax for set! of instance fields is different. An example implementation to make the above work:

(deftype Point [^{:volatile-mutable true} x]
  IPoint
  (getX [_] x)
  (setX [this v] (set! x v)))

There's also :unsynchronized-mutable. The difference is as the names would suggest to an experienced Java developer. ;-) Note that providing either annotation has the additional effect of making the field private, so that direct field access is no longer possible:

(.getX (Point. 10)) ; still works
(.x (Point. 10))    ; with annotations -- IllegalArgumentException, works without

Also, 1.2 will likely support the syntax ^:volatile-mutable x as shorthand for ^{:volatile-mutable true} x (this is already available on some of the new numerics branches).

Both options are mentioned in (doc deftype); the relevant part follows -- mind the admonition!

Fields can be qualified with the metadata :volatile-mutable true or :unsynchronized-mutable true, at which point (set! afield aval) will be supported in method bodies. Note well that mutable fields are extremely difficult to use correctly, and are present only to facilitate the building of higher level constructs, such as Clojure's reference types, in Clojure itself. They are for experts only - if the semantics and implications of :volatile-mutable or :unsynchronized-mutable are not immediately apparent to you, you should not be using them.

Clement

Thanks. You're a goldmine of information, glad to have you here :) – Nonunion

I want to emphasize... again... "you should not be using them". Do not use :volatile-mutable and :unsynchronized-mutable. Unless you already know this warning doesn't apply to you and understand why I am stating the warning again ;-) – Seadon

Answer 2

Like most things in Clojure, fields in types defined via deftype are immutable. While you can circumvent this using :volatile-mutable / :unsynchronized-mutable annotations, it is not common at all to do so. For one thing, such annotations will make the field private, so only the methods defined on the type will be able to access (and thus set) it. But more importantly, such constructs are susceptible to data races.

When mutability is required, idomatic Clojure will use one of Clojure's reference types like atom or ref.

Candelariacandelario