How do I map with rarely used state in clojure? - clojure

Question

The situation is as follows: I'm transforming a sequence of values. The transformation of each value breaks down into a number of different cases. Most values are completely independent of each other. However there is one special case that requires me to keep track of how many special cases I've encountered so far. In imperative programming this is pretty straightforward:
int i = 0;
List<String> results = new ArrayList<>();
for (String value : values) {
if (case1(value)) {
results.add(handleCase1(value));
} else if (case2(value)) {
...
} else if (special(value)) {
results.add(handleSpecial(value, i));
i++;
}
}
However in Clojure the best I've come up with is:
(first
(reduce
(fn [[results i] value]
(cond
(case-1? value) [(conj results (handle-case-1 value)) i]
(case-2? value) ...
(special? value) [(conj results (handle-special value i))
(inc i)]))
[[] 0] values))
Which is pretty ugly considering that without the special case this would become:
(map #(cond
(case-1? %) (handle-case-1 %)
(case-2? %) ...)
values)
The trouble is that I'm manually stitching a sequence together during the reduction. Also most cases don't even care about the index but must nonetheless pass it along for the next reduction step.
Is there a cleaner solution to this problem?

Answer 1

Sometimes code using loop and recur looks better than the equivalent code using reduce.
(loop [[v & more :as vs] values, i 0, res []]
(if-not (seq vs)
res
(cond
(case-1? v) (recur more i (conj res (handle-case-1 v)))
(case-2? v) (recur more i (conj res (handle-case-2 v)))
(special? v) (recur more (inc i) (conj res (handle-special i v))))))
Since there seems to be some demand, here is a version that produces lazy sequence. Customary warnings about premature optimization and keeping it simple apply.
(let [handle (fn handle [[v & more :as vs] i]
(when (seq vs)
(let [[ii res] (cond
(case-1? v) [i (handle-case-1 v)]
(case-2? v) [i (handle-case-2 v)]
(special-case? v) [(inc i) (handle-special i v)])]
(cons res (lazy-seq (handle more ii))))))]
(lazy-seq (handle values 0)))

Answer 2

You want a purely functional approach? Try using a Map collection for your temporary value needs. This keeps your results nice and clean, and an easy way to access those temporary values when needed.
When we encounter a special value, we also update the counter in the map as well as the result list. This way we can use reduce to store some state as we process, but keep everything purely functional without atoms.
(def transformed-values
(reduce
(fn [{:keys [special-values-count] :as m} value]
(cond
(case-1 value) (update m :results conj (handle-case-1 value))
(case-2 value) (update m :results conj (handle-case-2 value))
...
(special-case? value) (-> m
(update :results conj (handle-special value special-values-count))
(update :special-values-count inc))
:else m))
{:results [] :special-values-count 0}
your-list-of-string-values))
(:results transformed-values)
;=> ["value1" "Value2" "VALUE3" ...]
(:special-values-count transformed-values)
;=> 2

Answer 3

You can just use an atom to track it:
(def special-values-handled (atom 0))
(defn handle-cases [value]
(cond
(case-1? value) (handle-case-1 value)
(case-2? value) ...
(special? value) (do (swap! special-values-handled inc)
(handle-special #special-values-handled value))))
Then you can just do
(map handle-cases values)

Answer 4

There is nothing wrong in using a volatile! for this - in your case, it does not escape the context of the expression and does not create any mutability or threading complications:
(let [i (volatile! 0)]
(map #(cond
(case-1? %) (handle-case-1 %)
(case-2? %) (handle-case-2 %)
(special? %) (do (handle-special % #i)
(vswap! i inc)))
values)
You can use an atom instead if you are using Clojure < 1.7 or want to do it in a multi-threaded way (e. g. with pmap).

Answer 5

As Alejandro said, an atom allows one to easily keep track of mutable state and use it where needed:
(def special-values-handled (atom 0))
(defn handle-case-1 [value] ...)
(defn handle-case-2 [value] ...)
...
(defn handle-special [value]
(let [curr-cnt (swap! special-values-handled inc)]
...<use curr-cnt>... )
...)
(defn handle-cases [value]
(cond
(case-1? value) (handle-case-1 value)
(case-2? value) (handle-case-2 value)
...
(special? value) (handle-special value)
:else (throw (IllegalArgumentException. "msg"))))
...
(mapv handle-cases values)
Never be afraid to use an atom when a piece of mutable state is the simplest way to solve a problem.
Another technique I sometimes use is to use a "context" map as the accumulator:
(defn handle-case-1 [ctx value] (update ctx :cum-result conj (f1 value)))
(defn handle-case-2 [ctx value] (update ctx :cum-result conj (f2 value)))
(defn handle-special [ctx value]
(-> ctx
(update :cum-result conj (f-special value))
(update :cnt-special inc)))
(def values ...)
(def result-ctx
(reduce
(fn [ctx value]
(cond
(case-1? value) (handle-case-1 value)
(case-2? value) (handle-case-2 value)
(special? value) (handle-special value i)))
{:cum-result []
:cnt-special 0}
values))