Mutation Problem - Clojure

Question

having trouble changing an element of my function represented as a list.

code for random function:

(defn makerandomtree-10
[pc maxdepth maxwidth fpx ppx]
(if-let [output 
  (if (and (< (rand) fpx) (> maxdepth 0))
    (let [head (nth operations (rand-int (count operations)))
      children (doall (loop[function (list)
            width maxwidth]
              (if (pos? width)
            (recur (concat function 
              (list (makerandomtree-10 pc (dec maxdepth) 
                (+ 2 (rand-int (- maxwidth 1))) fpx ppx)))
              (dec width))
            function)))]
    (concat (list head) children))
    (if (and (< (rand) ppx) (>= pc 0))
    (nth parameters (rand-int (count parameters)))
    (rand-int 100)))]
output
))

I will provide also a mutation function, which is still not good enough. I need to be able to eval my statement, so the following is still insufficient.

(defn mutate-5
"chooses a node changes that"
[function pc maxwidth pchange]
(if (< (rand) pchange)
    (let [output (makerandomtree-10 pc 3 maxwidth 0.5 0.6)]
    (if (seq? output) output (list output)))
    ;mutate the children of root
    ;declare an empty accumulator list, with root as its head 
    (let [head (list (first function))
          children (loop [acc(list)
                  walker (next function)] (println "----------") (println walker) (println "-----ACC-----") (println acc)
            (if (not walker)
                acc
                (if (or (seq? (first function)) (contains? (set operations) (first function)))
                  (recur (concat acc (mutate-5 walker pc maxwidth pchange))
                    (next walker))
                  (if (< (rand) pchange)
                    (if (some (set parameters) walker)
                    (recur (concat acc (list (nth parameters (rand-int (count parameters)))))
                        (if (seq? walker) (next walker) nil))
                    (recur (concat acc (list (rand-int 100)))
                        (if (seq? walker) (next walker) nil)))
                    (recur acc (if (seq? walker) (next walker) nil))))
             ))]
        (concat head (list children)))))

(side note: do you have any links/books for learning clojure?)

Answer 1

Check out the clojure.walk namespace. It's likely that a function like clojure.walk/postwalk-replace is what you're looking for.