Clojure's map data type

Definition

A map in Clojure is a key-value data structure that stores associations between keys and values.

• Keys are unique (no duplicate keys)

• Maps are unordered by default (unless you use a sorted map)

• Maps are immutable (modifications return a new map instead of modifying the original)

Clojure supports two main types of maps:

• HashMap ({}) – Unordered, optimized for fast lookup.

• SortedMap (sorted-map) – Ordered by key, useful when ordering matters.

Syntax

A Clojure map is represented using curly braces {} with key-value pairs:

{:key1 value1, :key2 value2, :key3 value3}

Keys are often keywords (:name), but they can also be strings, symbols, or numbers.
Values can be anything, even map.

Common Use Cases

Clojure maps are used for:

• Data Representation – Storing structured information like user profiles, configurations, etc

• Associative Lookup – Fast key-based retrieval of values

• Transformations – Using functions like assoc, dissoc, merge, map, reduce on maps

• Sorting & Grouping – Organizing data using sorted-map or group-by

Practicing:

Create and Manipulate Maps
Create a map representing a student with keys :name, :age, and :grade. Add a new key :hobby with a value, and update the :grade to a new value.

(def student {:name "Johnny" :age "30" :grade "A"})
(def studentWithHobby (assoc student :hobby "Clojure"))
(def studentGotB (assoc studentWithHobby :grade "B"))

Access Map Values
Given a map of product prices (e.g., {:apple 1.2 :banana 0.5 :cherry 2.5}), retrieve the price of :banana and handle the case where a key does not exist (e.g., :orange).

(def productPrice {:apple 1.2 :banana 0.5 :cherry 2.5})
(productPrice :banana)
(productPrice :orange 0)

Filter Map Entries
Write a function that takes a map of people’s names and ages (e.g., {:Alice 30 :Bob 25 :Charlie 35}) and returns a new map with only people aged 30 or older.

(def people {:Alice 30 :Bob 25 :Charlie 35})
(defn filter30Above [people]
    (filter (fn [map-item] (> (val map-item) 30)), people)
  )

Merge Maps
Merge two maps: one containing a user's personal details and another containing their contact information. Handle any key conflicts by prioritizing the second map.

(def user {:id 123456 :fNmae "Ivan" :lName "Gavlik" :age 30 })
(def contact {:id 123456 :email "[e-mail]" :tel "[phone]"})
(def user-contact (merge user contact))

Map Keys and Values Transformation
Given a map of temperatures in Celsius for different cities (e.g., {:Berlin 20 :Paris 25 :Rome 30}), transform the values to Fahrenheit.

def city-temp-celsius {:Berlin 20 :Paris 25 :Rome 30})
(defn cel-to-feh
  [[key val-cel]] [key (+ (* val-cel 9/5) 32)]
  )
(def city-temp-fahrenheit
  (into {} (map cel-to-feh city-temp-celsius))
  )

Group by Key Values
Create a function that groups a sequence of maps (e.g., {:name "Alice" :department "IT"}) by the :department key.

(def employers [ {:name "Alice" :department "IT" }
                { :name "Marko" :department "HR" }
                {:name "Pero" :department "HR"}
                ])

(def bySector (group-by :department employers))

Remove Entries by Condition
Remove all entries from a map of products and their stock quantities (e.g., {:apples 5 :oranges 0 :pears 10}) where the stock is 0.

(def fruit-stock-quantities {:apples 5 :orange 0 :pears 10})
(defn exist-fruit-stock? [[fruit stock]]
  (> stock 0)
  )
(defn fruit-stock-good [fruit-stock]
  (filter exist-fruit-stock? fruit-stock-quantities)
  )
(def fruit-stock-report (into {} (fruit-stock-good fruit-stock-quantities)))

Nested Maps
Work with a nested map representing a school (e.g., {:class1 {:students ["Alice" "Bob"] :teacher "Ms. Smith"} :class2 {:students ["Charlie" "Dana"] :teacher "Mr. Johnson"}}). Add a new student to :class2.

(def school-class {
            :class1 {:students ["Alice" "Bob"] :teacher "Ms. Smith" }
            :class2 {:students ["Charlie" "Dana"] :teacher "Mr. Johnson"}
            }
  )

(defn new-student-class2 [student school-class]
  (let [class2-students (get-in school-class [:class2 :students])
        add-new-student (conj class2-students student)
        class-new-student (assoc-in school-class [:class2 :students] add-new-student)
        ]
    class-new-student
    )
  )

Count Map Entries
Write a function to count how many keys in a map have values greater than a given number. For example, in {:a 5 :b 10 :c 15}, count how many values are greater than 8.

(def letter-occurrence {:a 5 :b 10 :c 15})
(defn letter-occurrence-gt [n letter-occurrence]
  (let [filter-map (filter #(> (second %) n) letter-occurrence)
         ]
     (count filter-map)
    )
  ;;  (count (into [] (keys (filter #(> (second %) n)  letter-occurrence))))
  )

Sort Maps by Values
Sort a map of items and their prices (e.g., {:item1 20 :item2 10 :item3 30}) in ascending order of prices.

(def item-price-data {:item1 20 :item2 10 :item3 30 :item4 10})
(defn sorted-item-price [item-price] (into (sorted-map-by (fn [k1 k2]
                                          (compare [(get item-price k1) k1] [(get item-price k2) k2]))) item-price))

Task: Managing a Library System Using Maps

Scenario:

You are developing a simple library system to manage books and their availability. The system stores book records as maps, where each book has attributes like :id, :title, :author, :year, and :available?.

Your goal is to implement functions that:

• Initialize the Library – Create a collection of book records using maps

• Check Out a Book – Update a book’s availability status when a user borrows it

• Return a Book – Update the book’s availability when a user returns it

• Find Books by Author – Retrieve all books written by a specific author

• List Available Books – Return a list of books that are currently available

• Add a New Book – Insert a new book record into the collection.

• Remove a Book – Delete a book from the collection based on its :id

Solution

(def library
  [{:id 1 :title "Clojure for the Brave" :author "Daniel Higginbotham" :year 2015 :available? true}
   {:id 2 :title "The Joy of Clojure" :author "Michael Fogus" :year 2014 :available? true}
   {:id 3 :title "Programming Clojure" :author "Stuart Halloway" :year 2018 :available? false}])


(defn check-out-book [library book-id]
  (map #(if (= (:id %) book-id)
          (assoc % :available? false)
          %)
       library))

(defn return-book [library book-id]
  (map #(if (= (:id %) book-id)
          (assoc % :available? true)
          %)
       library))

(defn find-books-by-author [library author]
  (filter #(= (:author %) author) library))

(defn list-available-books [library]
  (filter :available? library))

(defn add-book [library new-book]
  (conj library new-book))

(defn remove-book [library book-id]
  (filter #(not= (:id %) book-id) library))


;; Example Usage
(def updated-library (check-out-book library 2))
(def returned-library (return-book updated-library 3))
(def books-by-author (find-books-by-author library "Michael Fogus"))
(def available-books (list-available-books library))
(def expanded-library (add-book library {:id 4 :title "New Book" :author "Some Author" :year 2023 :available? true}))
(def reduced-library (remove-book library 1))