modifications of a clojure tutorial

tutorialmod.clj

(def data {:people [{:username :bilbo} {:username :jim}]})

;;benign mutation.
(defn person-joined2 [state person]
  (let [username         (:username person)
        seen             (atom nil)
        is-joined-user? #(when (= username (:username %))
                           (reset! seen username))]
    (update state :people
            (fn [people]
              (as-> people xs
                (mapv (fn [user]
                        (if (is-joined-user? user)
                          (assoc user :online? true)
                          user)) xs)
                (if @seen xs (conj xs person)))))))

;;lifting state/check into accumulator
(defn person-joined3 [state person]
  (let [username         (:username person)
        is-joined-user? #(= username (:username %))]
    (update state :people
            (fn [people]
              (let [[seen acc] (->> people
                                    (reduce (fn [[seen acc] user]
                                              (let [seen (is-joined-user? user)]
                                                [seen
                                                 (conj acc (if seen
                                                             (assoc user :online? true)
                                                             user))]))
                                            [nil []]))]
                (if seen acc (conj acc person)))))))

;;low level lazy sequences with state in args.
(defn person-joined4 [state person]
  (let [username         (:username person)
        is-joined-user? #(= username (:username %))]
    (update state :people
            (fn [people]
              (let [aux (fn process [seen? xs]
                          (if-let [user (first xs)]
                            (lazy-seq
                             (if (is-joined-user? user)
                               (cons (assoc user :online? true)
                                     (process true (rest xs)))
                               (cons user (process seen? (rest xs)))))
                            (when-not seen? person)))]
                (aux false people))))))

;;assuming people is a vector.
(defn person-joined5 [state person]
  (let [username         (:username person)
        is-joined-user? #(= username (:username %))]
    (update state :people
            (fn [people]
              (if-let [idx (reduce-kv (fn [acc idx user]
                                        (if (is-joined-user? user)
                                          (reduced idx)
                                          acc)) nil people)]
                (update people idx assoc :online? true)
                (conj people person))))))