i need some algorithm help

i’ve got 2 if-lets and a cond inside of a loop

and i worry it’ll only get worse without outside assistance

i’ve pulled meta tags out of a web page with enlive, and i want to combine them into maps

i was using partition, but there’s no guarantee they repeat in the same order

@swizzard: so what form is the the data you have, and what form do you want it to be in?

the input is a seq of maps that look like this: {:attrs {:content "17" :itemprop "numTracks"} :content nil :tag :meta}

there are like 5 different itemprops that i want

so i want to turn a seq like ({:attrs {:content "17" :itemprop "numTracks"} :content nil :tag :meta} {:attrs {:content “foo" :itemprop "name"} :content nil :tag :meta}…) into a seq like ({“numTracks” “17”, “name” “foo”,…}…)

so you want to extract the :itemprop and :content keys from :attrs from each element and then accumulate them into a map. is that right?

right

but actually a seq of maps

({:attrs {:content "17" :itemprop "numTracks"} :content nil :tag :meta}
 {:attrs {:content "2009" :itemprop "copyrightYear"} :content nil :tag :meta}
 {:attrs {:content "10 Cc" :itemprop "byArtist"} :content nil :tag :meta}
 {:attrs {:content "Rock" :itemprop "genre"} :content nil :tag :meta}
 {:attrs {:content ""
          :itemprop "url"}
  :content nil
  :tag :meta}
 {:attrs {:itemprop "name"}
  :content ("Live in Concert: Clever Clogs")
  :tag :span}
 {:attrs {:content "14" :itemprop "numTracks"} :content nil :tag :meta}
 {:attrs {:content "1995" :itemprop "copyrightYear"} :content nil :tag :meta}
 {:attrs {:content "10 Cc" :itemprop "byArtist"} :content nil :tag :meta}
 {:attrs {:content "Rock" :itemprop "genre"} :content nil :tag :meta}
 {:attrs {:content ""
          :itemprop "url"}
  :content nil
  :tag :meta}
 {:attrs {:content "Avex" :itemprop "publisher"} :content nil :tag :meta}
 {:attrs {:itemprop "name"} :content ("Mirror Mirror") :tag :span}
 {:attrs {:content "8" :itemprop "numTracks"} :content nil :tag :meta}
 {:attrs {:content "1975" :itemprop "copyrightYear"} :content nil :tag :meta}
 {:attrs {:content "10 Cc" :itemprop "byArtist"} :content nil :tag :meta}
 {:attrs {:content "Rock" :itemprop "genre"} :content nil :tag :meta}
 {:attrs {:content ""
          :itemprop "url"}
  :content nil
  :tag :meta}
 {:attrs {:itemprop "name"} :content ("Original Soundtrack") :tag :span}
 {:attrs {:content "10" :itemprop "numTracks"} :content nil :tag :meta}
 {:attrs {:content "0" :itemprop "copyrightYear"} :content nil :tag :meta}
 {:attrs {:content "10 Cc" :itemprop "byArtist"} :content nil :tag :meta}
 {:attrs {:content "Rock" :itemprop "genre"} :content nil :tag :meta}
 {:attrs {:content ""
          :itemprop "url"}
  :content nil
  :tag :meta}
 {:attrs {:itemprop "name"} :content ("...meanwhile") :tag :span})

that’s the full input

which i want to yield 3 maps

i was using partition and then reduce merge

but that bakes in assumptions that make me really nervous

Are you getting 3 seqs by splitting at the span tags?

no

ahhh I see

i was just doing partition 6

but if there’s more or fewer attrs it’ll throw everything off

i think i could like write a transducer that wraps completed maps in reduced but that’s scary

You could use something like split-with to grab all tags until you get to a particular one. If you did that iteratively, it would have the same effect as your partition call.

yeah, but i’m not sure they’ll repeat in the same order

here's what I'm thinking (pseudocode): (reduce (fn [[cur-album & rest :as albums] tag] (if (already-has-tag cur-album tag) (conj albums (new-album tag)) (conj rest (merge cur-album tag)))) [] albums)

that should probably be a list, not a vector as the initial value

oh word

that makes sense, yeah

thanks!

no problem

the initial val should be something like ’({}), right?

yeah

the way I wrote it, you'd need an initial entry

@swizzard: I think it would make sense to map your tags into a more amenable format before combining them into albums. It's a lot easier to work with '({:num-tracks 17} {:copyright-year 2009} ...) than the format you get from enlive.

yeah

i can use map destructuring though

(fn [[cur-album & r :as albums] {{:keys [:itemprop :content]} :attrs cntnt :content}]…

I think the reason I shy away from that is it feels like making one piece of code do two things.

i hear that

I think it's fine.

I am a serial over-refactorer. 😛

honestly i’ve already got the map-validation function & don’t want to write another little helper function

that sounds very fair

whats the difference between using str or pr-str

The latter emits a string that can be parsed by the clojure reader

good to know, but admittedly im not quite sure what that means

@chadhs: i don't know if this will actually help, but it's analogous to the difference between str and repr in python

the idea is that you could e.g. copy the result of (pr-str my-thing) into the repl or some source code and get back my-thing

@chadhs: it's easier to understand the difference looking at pr vs print:

i shouldn't have used numbers, but notice the pr version roundtrips exactly if you use read

print/println is for "human" friendly, pr/prn is machine friendly

that makes sense @ghadi

pr-str just captures what it would have printed into a string, rather than printing

i just did a test route to show that in the browser

:body (str "Yo! " (:name (:route-params req)) "!”)

vs

and str calls .toString in java, which may not do any of the above

:body (pr-str "Yo! " (:name (:route-params req)) "!”)

and i could see the human friendly printed string vs the actual quoted strings