Clojure's defrecord - how to use it?

Question

I'm attempting to create my own immutable datatype/methods with defrecord in Clojure. The goal is to have a datatype that I can create instances of, and then call its methods to return a new copy of itself with mutated variables. Say a and b are vectors. I'd like to update a value in both and return a new copy of the entire structure with those vectors updated. This obviously doesn't compile, I'm just trying to get my ideas across.

(defrecord MyType [a b]   (constructor [N]     ; I'd like to build an initial instance, creating a and b as vectors of length N   )     (mutate-and-return []      ; I'd like to mutate (assoc the vectors) and return the new structure, a and b modified   ) ) 

I'd like to call the constructor and then the mutator as many times as I'd like (there are other functions that don't mutate, but I don't want to make it more complex for the question).

Alternatively, if this is not idiomatic Clojure, how are you supposed to do something like this?

Answer 1

Here's how you define your record:

(defrecord MyType [a b]) 

Note that in Clojure you don't typically define "methods" within your record type itself (the exception is if you want to directly implement a Java interface or a protocol).

A basic constructor (prefixed with ->) gets generated automatically for free:

(def foo (->MyType [1 2 3] [4 5 6]))  foo => #user.MyType{:a [1 2 3], :b [4 5 6]} 

You can then write more sophisticated constructor functions that use this, e.g.

(defn mytype-with-length [n]   (let [a (vec (range n))         b (vec (range n))]      (->MyType a b)))  (mytype-with-length 3) => #user.MyType{:a [0 1 2], :b [0 1 2]} 

And "mutate-and-return" also comes for free - you can just use assoc:

(assoc foo :b [7 8 9]) => user.MyType{:a [1 2 3], :b [7 8 9]}