help a beginner; it's good for your health

[rgkirch]

Hey! I hope you're having a great day.

I'm trying to figure out how to grab every item in this deep structure and return a flattened result.
This code:

(let [r2 [[0 {:active {:a {:ids [{:business "123"}
                                 {:business "aha"}]}
                       :b {:ids [{:business "234"}]}}}]
          [1 {:active {:d {:ids [{:business "567"}]}
                       :c {:ids [{:business "678"}]}}}]]
      f (fn [arg]
          (m/search
            arg
            (m/scan [?t {:active (m/scan [_ {:ids (m/scan {:business !a})}])}])
            [?t !a]))]

  (f r2))

gives me
([0 ["123"]] [0 ["aha"]] [0 ["234"]] [1 ["567"]] [1 ["678"]])
but I want
([0 ["123" "aha" "234"]] [1 ["567" "678"]])
Thanks for the help!

[noprompt]

One solution would be to recursively handle each element of the input sequence:

(let [r2 [[0 {:active {:a {:ids [{:business "123"}
                                 {:business "aha"}]}
                       :b {:ids [{:business "234"}]}}}]
          [1 {:active {:d {:ids [{:business "567"}]}
                       :c {:ids [{:business "678"}]}}}]]
      f (fn rec [arg]
          (m/find arg
            [[?t {:active (m/map-of _ {:ids (m/gather {:business !a})})}]
             & ?rest]
            (cons [?t !a] (rec ?rest))))]
  (f r2))
;; =>
'([0 ["123" "aha" "234"]] [1 ["567" "678"]])

From here we can switch to m/rewrite and use m/cata on the right.

(m/rewrite arg
  [[?t {:active (m/map-of _ {:ids (m/gather {:business !a})})}]
   & ?rest]
  ([?t [!a ...]] & (m/cata ?rest))
  
  _else ())

Going a little further still we can drop the recursion.

;; WRONG! IGNORE!
(m/rewrite arg
  (m/gather [!t {:active (m/map-of _ {:ids (m/gather {:business !a} !n)})}])
  ([!t [!a ..!n]] ...))

[rgkirch]

(m/rewrite
 [[0 {:active {:a {:ids [{:business "123"}
                         {:business "aha"}]}
               :b {:ids [{:business "234"}]}}}]
  [1 {:active {:d {:ids [{:business "567"}]}
               :c {:ids [{:business "678"}]}}}]]
 (m/gather [!t {:active (m/map-of _ {:ids (m/gather {:business !a} !n)})}])
 ([!t [!a ..!n]] ...))
;; => ([0 ["123" "aha"]] [1 ["234" "567" "678"]])

Have I correctly reproduced your example solution with the original example input? I'm getting undesirable output. It's returning [0 ["123" "aha"]] when I want [0 ["123" "aha" "234"]].

I also don't understand why this doesn't work. I see you're capturing the count into !n courtesy of gather. Then, you distribute !n number of !as into the answer with each !t.

... I think it should work.

[rgkirch]

Oh, because the count of !n is inside :ids? I actually want a count for !n that encompasses everything inside :active?

[noprompt]

@rgkirch Ah, yeah, you're right! My mistake! The last suggestion is wrong.

[rgkirch]

Thanks. I think I'd prefer mapping the rewrite over the sequence since that gives me a simpler rewrite rule.

(map
 (fn [arg]
   (m/rewrite
     arg
     [?t {:active (m/map-of _ {:ids (m/gather {:business !a})})}]
     [?t [!a ...]]))
 [[0 {:active {:a {:ids [{:business "123"}
                         {:business "aha"}]}
               :b {:ids [{:business "234"}]}}}]
  [1 {:active {:d {:ids [{:business "567"}]}
               :c {:ids [{:business "678"}]}}}]])

Is there a way to express the mapping with meander? You kinda implemented map in your solution with cata so I'm guessing that there isn't another way. I figure I should ask just in case. I can't think of anything...

[rgkirch]

This worked out really well; thank you for the help!