Collecting matches through `?:as*` into a map

[NoahTheDuke]

Hey hey,

I've been playing around with this library as my own pattern library isn't nearly as powerful, and I'm interested to know if this behavior is possible or would be considered:

I am matching against hiccup, specifically a [:table ...] element that can have an arbitrary number of :tr rows in the :tbody. I'm collecting these rows using this pattern:

(def csp-canoe-sprint
  (compile-pattern
    '[:table (? _ map?)
      [:thead (?:* (? head))]
      [:tbody
       (? _ map?)
       (?:as* rows
         (?:*
           [:tr (? _ map?)
            [:td (? _ map?) (? position parse-pos)]
            (?? _)
            [:td (? _ map?) [:a (?? _) (? winner string?)]]
            (?? _)
            [:td (? _ map?) [:a (?? _) (? NOC country-code->name)]]
            (?? _)
            [:td (? _ map?) [:span (? _ map?) (? medal #{"Gold" "Silver" "Bronze"})]]
            (?? _)]))]]))

When it matches, it results in a map with :head, :rows, :position, :winner, :NOC, and :medal. Each of the :rows is the whole matched [:tr ...] object, and the :position etc entries are vectors of the matches: ["Noah" "Santa"]. I'd like for there to be some way to "collect" the nested matches into individual maps, like rows of a csv: {:rows [{:position "1" :winner "Noah" :NOC "USA" :medal "Gold"} {:position "2" :winner "Santa" :NOC "North Pole" :medal "Silver"}]}.

Is this possible? If not, do you have ideas how I could achieve this?

EDIT: I know I could do this mapping myself because the match will only happen when each row is matched, so the length of position, winner, NOC, and medal will all be equal, but that requires manually constructing the maps for every pattern I write, which will be... arduous (I plan on having upwards of 100 patterns lol).

(let [match (csp-canoe-sprint table)]
  (mapv (fn [p w n m] {:position p :winner w :NOC n :medal m})
    (:position match)
    (:winner match)
    (:NOC match)
    (:medal match)))

[pangloss]

Hi, I guess there are a couple of ways of doing this but generalizing it really depends on how consistent this pattern is. You could implement a matcher to take a pattern like (?trdata {:position parse-pos :winner string ... }) which could probably do this if it's always the same general idea of extracting table data. It could replace the entire matcher starting at [:tbody ...]

Or if you've got lots of collections matching of various shapes, you could make the matcher the same and wrap the result with a higher order function maybe like (mapify pattern :position :winner :NOC :medal) which could basically do what your remapping does when you match.

Does that help?

Cheers, Darrick

[NoahTheDuke]

The second one seems like a smart idea, they would be consistent yes. I'm not sure what you mean by the first example. i can't change the shape of the hiccup, if that's what you mean.

[pangloss]

The second suggestion is probably the best place to start.

To clarify the first suggestion a little, there is a lot that you can do with custom matchers. You can use knowledge about the structure of your data to create specialized matchers. They extend what is possible to express in the patterns you write. For instance, when I built my M2 compiler, I used custom matchers to express rules for matching nodes in a graph. Likewise you could build a hiccup table matcher that builds in the structural assumptions and only requires you to specify a list of column names and column match rules, which was what I was trying to express earlier (much too tersely).

Matchers are moderately complex but completely self-contained, so once you understand how they're structured they are pretty easy to build to enhance the pattern language. They are also quite boilerplate-heavy. See the pattern.matchers namespaces.

[NoahTheDuke]

I see yeah, that seems cool and would be a significant increase in effort. I think i'll stick with a mapify approach for now. Thank you for the excellent library, it continues to impress and inspire me.