Question

I’m trying to parse a nested array structure of the following form:

[element [[child1] [child2] [child3 [[subchild1] [subchild2]]]]]

I would also like to return a list with all symbols (and nothing else), regardless of nesting depth; however, I’m not looking for flatmap or flatten etc, since I need to perform more complicated additional work on every element.

This is what I came up with so far:

(defn create-element [rs element]
  (if (symbol? element)
    (cons element rs)
    rs))

(defn parse
  ([rs element] (create-element rs element))
  ([rs element [children & more]] (if (nil? more)
                                    (parse (parse rs element) (first children))
                                    (parse (parse rs element) (first children) more))))

(defn n-parse [element]
  (apply parse () element))

This works fine for the following input:

=> (n-parse ['bla [['asd] ['kkk] ['sss]]])
(sss kkk asd bla)

But this doesn’t work:

=> (n-parse ['bla [['asd] ['kkk [['ooo]]] ['sss]]])
(sss kkk asd bla)

I’m still trying to wrap around my head around the types but can’t seem to manage to get it right. For example, Haskell makes this easy with pattern matching etc, whereas Clojure doesn’t allow same arity function overloading.

Also is there a more concise / idiomatic way (without having to resort to if?) I’d prefer pure Clojure solutions (no external libs) since this is actually for a Clojurescipt project.

Many thanks for any help!

Answer 1

I don’t see whats wrong with flatten. If you want to do some work on the items first, do the work first and then flatten the result:

(defn map-tree
      "Example: (map-tree + [1 2 [3 5]] [3 4 [5 6]])"
    [f & trees]
    (if (every? coll? trees)
        (apply map (partial map-tree f) trees)
        (apply f trees)))

(defmulti transformator identity)
;; transform 'sss element into something special
(defmethod transformator 'sss [_] "sss")
;; default transformation
(defmethod transformator :default [v] v)

Test:

user> (flatten (map-tree transformator '[bla [[asd] [kkk] [sss]]]))
(bla asd kkk "sss")
user> 

Would that not work?