Converting a javascript function using Clojure

You want the cond-> macro:

(defn build-string [some-integer]
  (let [question "Initial text; "]
    (cond-> question
      (= some-integer 1) (str "Add string one")
      (= some-integer 2) (str "Add string two")
      (= some-integer 3) (str "Add string three"))))

(build-string 1) => "Initial text; Add string one"
(build-string 2) => "Initial text; Add string two"
(build-string 3) => "Initial text; Add string three"

although in this case plain old cond will work:

(defn build-string [some-integer]
  (let [question "Initial text; "]
    (cond
      (= some-integer 1) (str question "Add string one")
      (= some-integer 2) (str question "Add string two")
      (= some-integer 3) (str question "Add string three"))))

@cfrick makes a good point:

(defn build-string-map [some-integer]
  (let [question "Initial text; "
        data     {1 "Add string one"
                  2 "Add string two"
                  3 "Add string three"}
        suffix   (get data some-integer)
        result   (str question suffix)]
    result))


(build-string-map 1) => "Initial text; Add string one"
(build-string-map 2) => "Initial text; Add string two"
(build-string-map 3) => "Initial text; Add string three"

Be sure to look at the

• Clojure CheetSheet
• ClojureScript CheetSheet
• clojure.org
• clojurescript.org

Your cond form is fine, but you can use case here:

(defn build-string [some-integer]
  (str "Initial text"
       (case some-integer
         1 "Add string one"
         2 "Add string two"
         3 "Add string three")))

Your “immutable string question”: in contrast to your JavaScript version, none of the operators you or I have been using modify any of their arguments. For example, Clojure's str builds a new string, but JavaScript's += modifies a variable. You need not worry: it is not a mistake to modify things in Clojure that you would need to keep an eye out for, but rather the language makes it difficult to do it in the first place. If you see a simple function using standard operators, it is very improbable for it to be doing something unsafe.

If you have just some "equal number" checks, i'd just go with a map. E.g.

(str "Initial text" ({1 "Add string one" 2 "Add string two" 3 "Add string three"} some-integer))

Or just go with condp. E.g.

(defn build-string  
  [some-integer]
  (str "Initial text"
       (condp = some-integer
         1 "Add string one"
         2 "Add string two"
         3 "Add string three"
         nil)))

(map build-string (range 4))
; => ("Initial text" "Initial textAdd string one" "Initial textAdd string two" "Initial textAdd string three")

I think the keypoint here is to eliminate duplication; not only eliminate the "length" but also eliminate the "width" of your code.