Comments on: Learning Clojure #13: Making my code suck less

By: Alex Miller

Alex Miller — Fri, 22 Apr 2011 20:07:40 +0000

@Steve: You’re right on array-map of course. I was thinking about the internal implementation which is backed by an array and indexed by ints but that’s not relevant to the use of it which is arbitrary keys and values.

I hadn’t run across map-indexed at the time of this writing, but that’s good stuff.

On (apply str (interpose ” ” … ) ), that is basically the definition of clojure.string/join (except join uses the more efficient path of creating a StringBuilder).

By: Steve Miner

Steve Miner — Fri, 22 Apr 2011 19:50:23 +0000

An array-map is a map that preserves the order of the keys. For small maps (less than 10 keys) it can be useful to have a guaranteed order (for seq, etc.). (Your text implied that the keys had to be “indexes” which sounds confusing to me.)

With Clojure 1.2, you can use map-indexed to solve your original problem. interpose is good for handling the space in between clauses.

(defn make-clauses [props]
(apply str (interpose ” ” (map-indexed #(format “make str with %s and %d.” %2 %1) props))))

By: Neal Ravindran

Neal Ravindran — Fri, 02 Apr 2010 10:36:32 +0000

While clojures are a good thing that enable us to write cute code ..it might be a bad thing for readability and maintainability(the after-life of code). Generally speaking…the guys who maintain code may not be an ace developer like the one who wrote it, but some entry-level guy with minimal java knowledge who may need some significant ramp-up time.

So in effect…I would not deviate from the usage of StringBuilder to build up a string…ever! :)

By: Daniel Janus

Daniel Janus — Tue, 30 Mar 2010 19:56:42 +0000

You could also use my clj-iter library and write something along the lines of:

(defn make-clauses-mac [props]
(apply str
(iter (for prop in props)
(for i from 0)
(collect (format “make str with %s and %d. ” prop i)))))

the macroexpansion of which would be very similar to your initial example.

By: Mac

Mac — Mon, 15 Mar 2010 15:34:12 +0000

I prefer

(use ‘clojure.contrib.seq-utils)
(defn make-clauses-mac [props]
(map #(str “make str with ” (nth % 1) ” and ” (nth % 0) “.”) (indexed props)))

user=> (make-clauses-mac ‘(foo1 foo2 foo3))
(“make str with foo1 and 0.” “make str with foo2 and 1.” “make str with foo3 and 2.”)

I like map, because you can parallelize it easily by just switch to pmap. and indexed
returns a vector pair, which allows indexed access via nth in log32N hops.