CODEWITHSUNDEEP
clojure
Pavel Ganelin
Pavel Ganelin

Reputation: 314

Clojure: map function with updatable state

What is the best way of implementing map function together with an updatable state between applications of function to each element of sequence? To illustrate the issue let's suppose that we have a following problem:

I have a vector of the numbers. I want a new sequence where each element is multiplied by 2 and then added number of 10's in the sequence up to and including the current element. For example from:

[20 30 40 10 20 10 30]

I want to generate:

[40 60 80 21 41 22 62]

Without adding the count of 10 the solution can be formulated using a high level of abstraction:

(map #(* 2 %) [20 30 40 10 20 10 30])

Having count to update forced me to "go to basic" and the solution I came up with is:

(defn my-update-state [x state]
  (if (= x 10) (+ state 1) state)
  )

(defn my-combine-with-state [x state]
  (+ x state))

(defn map-and-update-state [vec fun state update-state combine-with-state]
  (when-not (empty? vec)
    (let [[f & other] vec
          g (fun f)
          new-state (update-state f state)]
      (cons (combine-with-state g new-state) (map-and-update-state other fun new-state update-state combine-with-state))
      )))


(map-and-update-state [20 30 40 50 10 20 10 30 ] #(* 2 %) 0 my-update-state my-combine-with-state )

My question: is it the appropriate/canonical way to solve the problem or I overlooked some important concepts/functions.

PS:

  1. The original problem is walking AST (abstract syntax tree) and generating new AST together with updating symbol table, so when proposing the solution to the problem above please keep it in mind.

  2. I do not worry about blowing up stack, so replacement with loop+recur is not my concern here.

  3. Is using global Vars or Refs instead of passing state as an argument a definite no-no?

Upvotes: 1

Views: 440

Answers (4)

Airat
Airat

Reputation: 73

The most appropriate way is to use function with state

(into
  []
  (map
    (let [mem (atom 0)]
      (fn [val]
        (when (== val 10) (swap! mem inc))
        (+ @mem (* val 2)))))
  [20 30 40 10 20 10 30])

also see

memoize

standard function

Upvotes: 0

icamts
icamts

Reputation: 186

Reduce and reductions are good ways to traverse a sequence keeping a state. If you feel your code is not clear you can always use recursion with loop/recur or lazy-seq like this

(defn twice-plus-ntens
  ([coll] (twice-plus-ntens coll 0))
  ([coll ntens]
    (lazy-seq
      (when-let [s (seq coll)]
        (let [item (first s)
              new-ntens (if (= 10 item) (inc ntens) ntens)]
          (cons (+ (* 2 item) new-ntens) 
                (twice-plus-ntens (rest s) new-ntens)))))))

have a look at map source code evaluating this at your repl

(source map)

I've skipped chunked optimization and multiple collection support.

You can make it a higher-order function this way

(defn map-update
  ([mf uf coll] (map-update mf uf (uf) coll))
  ([mf uf val coll]
    (lazy-seq
      (when-let [s (seq coll)]
        (let [item (first s)
              new-status (uf item val)]
          (cons (mf item new-status) 
                (map-update mf uf new-status (rest s))))))))

(defn update-f
  ([] 0)
  ([item status]
    (if (= item 10) (inc status) status)))

(defn map-f [item status]
  (+ (* 2 item) status))

(map-update map-f update-f in)

Upvotes: 0

Changgeng
Changgeng

Reputation: 588

To count # of 10 you can do

(defn count-10[col]
  (reductions + (map #(if (= % 10) 1 0) col)))

Example:

user=> (count-10 [1 2 10 20 30 10 1])
(0 0 1 1 1 2 2)

And then a simple map for the final result

(map + col  col (count-10 col)))

Upvotes: 3

Lee
Lee

Reputation: 144206

You can use reduce to accumulate a pair of the number of 10s seen so far and the current vector of results.:

(defn map-update [v]
  (letfn [(update [[ntens v] i]
             (let [ntens (+ ntens (if (= 10 i) 1 0))]
               [ntens (conj v (+ ntens (* 2 i)))]))]
    (second (reduce update [0 []] v))))

Upvotes: 3

Related Questions