Fork me on GitHub
Frank Jay01:03:05

(defn eval-not



(and (seq? (second input)) (= 'and (first (second input)))) ;(do x here which -> (or (not x) (not y))
If the user types in: (eval-not '(not (and x y))), is there a way to return (or (not x) (not y)) Without using macros and without changing the style of code I have already written above. I asked this question before, but I was not very specific as to what I was asking. I hope this question is better written.


is there any particular reason the style of the code can’t be changed?


@U7RJTCH6J yes there is: it's a homework assignment πŸ™‚

bananadance 8
πŸ˜… 4
Frank Jay03:03:36

Well. I created the homework assignment and I did any other functions in the same format. Would appreciate any advice :)


(defn demorgan
    (atom? form)

    (and (= 'not (first form))
         (sequential? (second form))
         (= 'and (first (second form))))
    (let [[_ [_ & terms]] form]
      (list* 'or (map (comp #(list 'not %) demorgan) terms)))



(demorgan '(not (and x y)))
(demorgan '(not (and (not (and x y)) z)))


I am sure there is a function to convert the following collection of albums to be grouped by artists instead, or is this in need of a reducing function?

(def music-collection
  [{:album-name "Tubular Bells" :artist "Mike Oldfield"}
   {:album-name "Smells like teen spirit" :artist "Nirvana"}
   {:album-name "Vision Thing" :artist "Sisters of Mercy"}
   {:album-name "Here comes the war" :artist "New Model Army"}
   {:album-name "Thunder & Consolation" :artist "New Model Army"}])
So the results would look like
{"Mike Oldfield"    ["Tubular Bells"]
 "Nirvana"          ["Smells like teen spirit"]
 "Sisters of Mercy" ["Vision Thing"]
 "New Model Army"   ["Here comes the war" "Thunder & Consolation"]}


I suggest trying a group-by followed by a map to convert the values to a vector.

πŸ‘ 4

I tried group-by after I partitioned it and made a mess πŸ™‚ group-by :artist music-collection on its own does a better job, although its not quite the right shape and artist details repeated. An anonymous function with group-by should fix it I think


This loop-recur does what I was looking for, but its so much code πŸ™‚

(loop [albums    music-collection
       by-artist {}]
  (let [album (first albums)]
    (if (empty? albums)
      (recur (rest albums)
             (update by-artist
                     (keyword (:artist album))
                     conj (:album-name album))))))


hmm, loop-recur is the only approach that works so far 😞


As mentioned above you could try something like that

(reduce-kv (fn [m k v] (assoc m k (map :album-name v)))
           (group-by :artist music-collection))


The above works great, also if you wanted to do it using purely sequence function (and for example if you don't remember reduce-kv's syntax off the top of your head)

(defn artist->albums
  (->> coll
       (group-by :artist)
       (map (fn [[k v]]
              [k (mapv :album-name v)]))
       (into {})))


^^ is good and here's the same thing using a transducer instead of ->>.

(into {}
    (map (fn [[k v]]
           [k (mapv :album-name v)]))
    (group-by :artist music-collection))

πŸ’― 4
Luis C. Arbildo16:03:12

Any form to express it more short and intuitive?

Luis C. Arbildo16:03:05

maybe without necessity to use the function int-or-nothing


That if-let global is bad

Luis C. Arbildo17:03:57

Is just an example

Luis C. Arbildo17:03:12

if-let is in a function


probably cond-> by the looks


wait you only have a single condition there

Luis C. Arbildo17:03:09

yes, I just want to corroborate if this difference is greater than 0, and asign this value to a variable


(let [diff (- ...)]
  (when (> diff 0)
    (str diff)))


btw it's generally considered bad-form to use if-let and if without else branches. if you have no else branch use when and when-let

πŸ‘ 8
Luis C. Arbildo17:03:43

Thank you for that!


no worries


@UUGUA0MGQ if you don't mind, please post text instead of images, much easier to read for me anyway. To get syntax coloring you can post a snippet with Ctrl-Shift-Enter and select Clojure for the Type.