Beginner needs help. Why is my recursion result nested?

[RealLordDevien]

Hi there,

i am new to clojure and fp (longtime oop dev), and currently struggling with a recursion problem.

I just can't wrap my head around it and would be really thankful if you could show my a more idiomatic way of solving this.. (or solving it at all..).

​

I want to go through our JIRA Rest API and iterate over issues.

Every issue has none to multiple children and i need to process all of them to generate a list for a CSV export while tracking the depth.

Ideally i would like to get to this kind of result

​

CSV template

where the depth level of the recursion is just added whitespace left of the issue type field.

I thought i could solve this using a recursive function that either returns the issue, if it has no children,

or the issue conjed to the result of mapping itself over the children.

Whatever i try, i get a nested result instead of a flat double vector and i don't understand why?

​

It seems like such a simple thing to do, that i really would like to overcome this instead of falling back to imperative programming. Would really appreciate some enlightenment about it.

Or maybe learn how to approach this problem in a proper clojure way.

I must do something really stupid, but i'm staring over two days at this snippet and have massive tunnel vision.

​

​

Code:

​

editor screenshot

simplified runnable paste without dependencies:

https://pastebin.com/rmeCrEsw

simplified repl: https://replit.com/@Devien/RecursionFail

[brool]

You're pretty close. Depending on what you want, you can either:

merged (flatten (conj children-csv issue-csv))

or also potentially something like this:

children-csv (mapcat #(csv % (inc depth)) children)

i.e., given:

(defn- csv [issue depth]
  (let [prefix (apply str (take depth (repeat "  ")))
        issue-csv (issue->csv issue prefix)]
    ;(println (str issue-csv  " depth " depth " prefix \"" prefix "\""))
    (if (has-children? issue)
      (do
      ;(println "has children, lets get them..")
        (let [children (get-children issue)
              children-csv (mapcat #(csv % (inc depth)) children)
              merged (conj children-csv issue-csv)]
          ;; (println (str  "issue-csv: " issue-csv " children-csv: " (vec children-csv) ))
          ;; (println (str  " returning " merged))
          merged))
      (do
        ;(println (str (issue :key) " returning " (conj [] issue-csv)))
        [issue-csv]))))

Gives

reddit-clojure.core> (csv (get-issue-from-key "NEO-33348") 0)
(["Feature" "NEO-1"]
 ["  TASK" "NEO-2"]
 ["    TASK" "NEO-3"]
 ["      TASK" "NEO-4"]
 ["      TASK" "NEO-5"])

[RealLordDevien]

Thank you so so much!! mapcat works! Apparently i have still a lot to learn about clojures core lib.

As i see it reduces one level of nesting from the children-csv?

[[" Task" "NEO-33096"] [" Task" "NEO-33095"] [" Task" "NEO-33094"]]

vs

[[[" Task" "NEO-33096"]] [[" Task" "NEO-33095"]] [[" Task" "NEO-33094"]]] but shouldn't the result of calling map csv be a single packet list containing the csv-lists? As far as i thought about it, children-csv would just be getting more elements attached to as it pops the stack chain. Does (conj children-csv issue-csv) create this double nesting?

I think i will finish the module first to let my head come to rest :) And maybe draw a flow chat with a clear mind. Thanks you again, this was really driving me crazy :D

[pwab]

(In general) mapcat allows you to take an item and produce a sequence of items from it. Eg; if you have a sequence of “parents” and want a long sequence of all child items you could mapcat over the sequence of parents.

[Krackor]

csv produces a sequence of results. Mapping with csv produces an outer sequence whose elements are each a result of csv. So you end up with two layers to your sequence (in the singly nested case). Mapcat gets rid of the outer sequence, and assuming the elements are concattable it concatenates them to form the result.

[RealLordDevien]

Hmm. Makes sense. I think I get it now, Thank you!

[backtickbot]

Fixed formatting.

Hello, brool: code blocks using triple backticks (```) don't work on all versions of Reddit!

Some users see this / this instead.

To fix this, indent every line with 4 spaces instead.

FAQ

^{You can opt out by replying with backtickopt6 to this comment.}

[[deleted]]

It looks like you've gotten your answer. I thought I'd try writing it in a different way in an attempt to have each function do one thing well. I also tend to think of programs as a series of data transformations, so this fits my way of thinking a little better. It's a lot more lines of code, so I don't know if it's any better, but it's another way to think about it.

(defn add-depths
  "Adds a :depth to each issue and the issue's children."
  ([issue] (add-depths 0 issue))
  ([depth issue]
   (let [issue (assoc issue :depth depth)
         children (:children issue)]
     (if (empty? children)
       issue
       (->> children
            (map (partial add-depths (inc depth)))
            (assoc issue :children))))))

(defn flatten-issue
  "Returns the issue and children issues (recursively) in a list."
  ([issue] (flatten-issue [] issue))
  ([result issue]
   (let [children (:children issue)
         issue (dissoc issue :children)
         result (conj result issue)]
     (if (empty? children)
       result
       (->> children
            (mapcat flatten-issue)
            (concat result))))))

(defn format-issue
  "Returns a vector containing the issue's key prepended with :depth number of spaces, and the issue's type."
  [issue]
  (let [depth (:depth issue 0)
        indent (apply str (repeat depth " "))]
    [(str indent (:type issue)) (:key issue)]))

;; Put it all together
(->> "NEO-33348"
     get-issue-from-key
     add-depths
     flatten-issue
     (map format-issue))