Updating one map in a vector of maps in clojure - vector

Question

I have done a lot of searching on this and not found an answer to my specific problem. As background I am taking a coding bootcamp on Java and we are learning JavaScript and Clojure alongside Java. The course content is roughly Java: 50% / JavaScript 30% / Clojure 20%. Having advanced beyond my classmates I am tackling a challenge from my instructor.
I have built an app in Clojure to manage an animal shelter. I am using a vector of hashmaps as my central data store. Things that I have succeeded in doing:
Loading sample data from a hard coded array of hashmaps.
Creating a new animal and adding it's hashmap to the array.
Listing the entire "table" of animals (data from one hashmap per line)
Displaying a multiline detailed view of one animal's record.
What I am struggling with at the moment is my edit function. It is supposed to display the chosen animal's existing data and take any edits the user wants to make then update a working copy of the hashmap and finally update the working copy of the array.
(defn edit-animals [animals]
;; ask which animal to edit index is 1 based from the UI
(let [index (wait-for-int "Please enter the idex of the animal to edit. Enter 0 to display the list of animals" 0 (count animals))]
;; if the user typed a valid index
(if (> index 0)
;; then edit the animal
(let [index (- index 1) ;; index is 0 based for indexing the array
animals animals
animal (nth animals index)
;; prompt with existing data and ask for new data
name (wait-for-string (str "Name: " (:name animal) "\n") false)
species (wait-for-string (str "Species: " (:species animal "\n")) false)
breed (wait-for-string (str "Breed: " (:breed animal "\n")) false)
description (wait-for-string (str "Description: " (:description animal "\n")) false)
;; check for null returns from user
name2 (if (= name "") (:name animal) name)
species2 (if (= species "") (:species animal) species)
breed2 (if (= breed "") (:breed animal) breed)
description2 (if (= description "") (:description animal) description)
;; update local copy of animal
animal (assoc animal :name name2 :species species2 :breed breed2 :description description2)]
;; assoc fails to update animals
;; assoc-in crashes at runtime
animals (assoc animals index animal))
;;(wait-for-enter "\nPress enter to return to the menu")
;; else dispolay the list of animals
(display-animals animals)))
animals)
I have run this code in my debugger and verified that everything is working as expected up to the line:
animal (assoc animal :name name2 :species species2 :breed breed2 :description description2)
The next line fails in one of two ways as I have documented in the comments.
I am aware that atom may be a better way to do this but so far the vector of maps that is constantly passed around is working, so I would like to find a solution to my current problem that does not involve using atom. Once I get this problem solved I plan to switch the project to an atomic data structure. But is a project for another day.
If I have missed a relevant discussion here, please point me in the right direction!

Answer 1

The line:
animals (assoc animals index animal))
does not do what you think it does -- it is not inside the let binding vector.
First of all, good job, you asked the question the right way (with examples, etc.). Congratulations on your coding course. My recommendation would be to keep doing what you're doing, and learn to think in clojure in a very different way than you think in java. They are both worthwhile, just different in approach. In your code, you are doing numerous "temporary assignments" (such as name2 for example). The fact that your let binding vector has 11 pairs is a red flag that you're doing too much. The second item in let, animals animals is particularly strange.
Instead, try to think about the evaluation of expressions rather than the assignment of values. name2 = name1 + ... is a statement, and not an expression. It doesn't do anything. Instead, in a declarative language, almost everything is an expression. In the code below (which I just an extension of what you've done and not necessarily how I'd do it from scratch), note that no local bindings are re-bound (nothing is "assigned to" more than once). let allows us to lexically bind name to the result of an expression, and then we use name to achieve something else. not-empty allows us to do better than using name and name2, which is what you have done.
(def animals [{:name "John" :species "Dog" :breed "Pointer" :description "Best dog"}
{:name "Bob" :species "Cat" :breed "Siamese" :description "Exotic"}])
(defn edit-animals
[animals]
(if-let [index (dec (wait-for-int "Please enter the index of the animal to edit. Enter 0 to display the list of animals" 0 (count animals)))]
(let [animal (nth animals index)
name (or (not-empty (wait-for-string (str "Name: " (:name animal) "\n") false))
(:name animal))
species (or (not-empty (wait-for-string (str "Species: " (:species animal) "\n") false))
(:species animal))
breed (or (not-empty (wait-for-string (str "Breed: " (:breed animal) "\n") false))
(:breed animal))
description (or (not-empty (wait-for-string (str "Description: " (:description animal) "\n") false))
(:description animal))
animal {:name name :species species :breed breed :description description}]
(println "showing new animal: " animal)
(assoc animals index animal))
animals))
(def animals (edit-animals animals))
Note that this does not really achieve much other than restructuring your code. It really does too much, and is not a good example of how a function should do one thing well. But I think your goal for now should be to be a little more idiomatic and get away from the imperative mentality, when you write your clojure. After you do that, you can focus on the design part of it.
Keep up the good work and ask any more questions you have!

Answer 2

in short, you have to return the animals bound in your innermost let (it index > 0), else display current animals and return it. So it would be like this:
(defn edit-animals []
(let [index ...]
(if (> index 0)
;; for an acceptable index you query for input, modify animals, and return modified collection
(let [...]
(assoc animals index animals))
;; otherwise display initial data and return it
(do (display animals)
animals))))
But i would restructure the code more, to make it more clojure-style. First of all i would extract the updating of the animal with input to standalone function, to remove name, name2, breed, breed2... bindings that make the let bindings messy. (upd-with-input), and replace assoc with update. Something like this:
(defn edit-animals [animals]
(letfn [(upd-with-input [animal field prompt]
(let [val (wait-for-string (str prompt (field animal) "\n") false)]
(if (clojure.string/blank? val)
animal
(assoc animal field val))))]
(let [index (dec (wait-for-int "enter index" 0 (count animals)))]
(if (contains? animals index)
(update animals index
(fn [animal]
(-> animal
(upd-with-input :name "Name: ")
(upd-with-input :species "Species: ")
(upd-with-input :breed "Breed: ")
(upd-with-input :description "Description: "))))
(do (when (== -1 index) (display animals))
animals)))))
then i would think of separating the whole part collecting user input from actually updating animals collection.

Answer 3

I think you want to delete animals from
animals (assoc animals index animal))
at the end of the if statement and instead return the result of the function
(assoc animals index animal)
or display them
(display-animals (assoc animals index animal))