Question

From googling around, I found that using while loops or using variables is discouraged.

Now I implemented a very simple algorithm that will read characters from an inputstream and parse accordingly: if input is 10:abcdefghej it will parse out 10 then read next 10 bytes after the colon.

The thing I am kinda lost with is how I can refactor this so it does not rely on variables.

(defn decode-string [input-stream indicator]

  (with-local-vars [length (str (char indicator) )
            delimiter (.read input-stream ) 
            string (str "")
            counter 0 ]

    (while (not(= (var-get delimiter) 58 ))
       (var-set length (str (var-get length) (char (var-get delimiter)) ))
       (var-set delimiter (.read input-stream )))

    (var-set length (new BigInteger (var-get length)) )
    (var-set counter (var-get length))

    (while (not(zero? (var-get counter) ))
       (var-set string (str (var-get string) (char (.read input-stream ))  ))
       (var-set counter (dec (var-get counter))))
    (var-get string)))

Also, I understand that the only way to declare variables is using the with-local-vars keyword. Isn’t it kind of unpractical to define all the variables in one block at the beginning, or am I missing some crucial point?

Answer 1

A bit late to this party, I suppose, but the problem is much simpler if you just treat the string as a sequence of characters and use Clojure’s sequence-handling primitives:

(defn read-prefixed-string [stream]
  (let [s (repeatedly #(char (.read stream)))
        [before [colon & after]] (split-with (complement #{\:}) s)
        num-chars (read-string (apply str before))]
    (apply str (take num-chars after))))

user> (let [in (java.io.StringReader. "10:abcdefghij5:klmnopqrstuvwxyz")]
        (repeatedly 2 #(read-prefixed-string in)))
("abcdefghij" "klmno")

A summary:

• Convert the ugly, side-effectful input stream into a lazy sequence of characters, so that we can pretend it’s just a string for the rest of this operation. As you can see, no more characters are actually read from the stream than are necessary to compute the result.
• Split the string into two parts: the first half characters before the first colon, and the second half whatever is left.
• Use destructuring to bind those parts to locals named before and after, and strip out the : while we are at it, by binding it to an unused local, named colon for descriptiveness.
• Read before to get its numerical value
• Take that many characters from after, and mash them all together into a string with (apply str)

Svante’s answer is an excellent example of how to write loop-ish code with Clojure; I hope that mine is a good example of assembling the built-in functions so that they do what you need. Certainly both of these make the C solution look anything but “very simple”!