parent should not be queued after processing. You have visited set, for visited nodes. It doesn’t make sense to re-visit the parent node again. Or is it your specific use case?

I have a single thread that can process nodes. Parents need all of their children resolved before they can be processed.

Smth like this?

def dfs(source, visited):
    if source in visited: return

    visited.add(source)

    for child in children[source]:
        dfs(child, visited)
    
    # do your logic here with source

I think order would be wrong for me, the for would need to come before visited.add

Maybe I need to do something closer to a toposort.

I don't really have a compsci background, so I'm spear fishing

you can not do toposort in a graph with a cycle

> the for would need to come before visited.add how come?

the visited.add is there in order to prevent calling a node twice or more.

My code does exactly what you said. > Parents need all of their children resolved before they can be processed

aka post-traversal

Oh, I would go over visited in reverse?

LIFO?

My graph doesn't have a cycle, it's a tree

Which might not be a clear way of describing it. My data is hierarchical.

https://en.wikipedia.org/wiki/Tree_traversal#Post-order_(LRN) aha!

wikipedia knows more than I expected, and is rather useful

> Oh, I would go over visited in reverse? sure. But this is what you want → child before parent. It should be this way

(defn post-order-tree-seq
  [branch? children root]
  (let [walk (fn walk [n]
               (if (branch? n)
                 (concat (mapcat walk (children n)) [n])
                 [n]))]
    (walk root)))

Great!

I've had that experience so many times, until eventually I got used to always double-checking whether there's a function in core that'll immediately solve my problem 😉