I'm new to Clojure, and I've been translating some data manipulation work I did recently as an aid to learning. I've got a function translation that works fine, and is shorter, but feels much less readable. Can anyone suggest a more readable and/or more idiomatic way to handle this?
In Python:
def createDifferenceVector(v,startWithZero=True):
deltas = []
for i in range(len(v)):
if i == 0:
if startWithZero:
deltas.append(0.0)
else:
deltas.append(v[0])
else:
deltas.append(v[i] - v[i-1])
return deltas
My attempt at a Clojure translation:
(defn create-diff-vector [v start-zero]
(let [ext-v (if start-zero
(cons (first v) v)
(cons 0 v))]
(for [i (range 1 (count ext-v))]
(- (nth ext-v i) (nth ext-v (- i 1))))))
It could be that it's less readable just because of my inexperience with Clojure, but in particular, the trick of prepending an element to the input vector feels to me like it obscures the intention. All the solutions I tried which didn't use the prepending trick were much longer and uglier.
Many sequence transformations are incredibly elegant in Clojure, but the ones that I find challenging so far are ones like this one, which a) lend themselves to manipulation by index rather than by element, and/or b) require special handling for certain elements.
Thanks for any suggestions.
Idiomatic Clojure tends to manipulate the sequences as a whole, rather than individual elements. You could define create-diff-vector
in English as:
The result is a vector consisting of:
start-zero
is true or false, respectively; followed byThe second part can be illustrated thusly: for the input (31 41 59 26 53)
, we have
input without the first element: (41 59 26 53) - input without the last element: (31 41 59 26) =================================================== result: (10 18 -33 27)
Which, translated to Clojure, becomes remarkably concise:
(defn diff-vector [v start-zero?]
(into [(if start-zero? 0 (first v))]
(map - (rest v) v))))
A few points to note:
start-zero?
serves as a hint that a boolean is expected here.map
ping a function over sequences of different lengths terminates upon the end of the shortest sequence.This implementation would be more idiomatic:
(defn create-diff-vector [v start-with-zero?]
(let [v (cons (if start-with-zero? (first v) 0) v)]
(map - (rest v) v)))
I first prepend either the first value of the vector or 0 to the input vector. Then I use map
to subtract the vector from itself, shifted by one position.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With