         #?(:clj (over (eval parents) child1 child2))
 
         true
-        (let [parent (first parents)]
+        (let [parent (first parents)] ;; TODO: use recur
           (cond
             (nil? (get-in parent [:schema-symbol] nil))
             (throw (exception (str "no schema symbol for parent: " (:rule parent))))

        nil

        (and (map? parents)
             (not (nil? (:serialized parents))))
        ;; In this case, supposed 'parent' is really a lexical item: for now, definition of 'lexical item' is,
        ;; it has a non-nil value for :serialized - just return nil, nothing else to do.
        (throw (exception (str "Don't know what to do with this parent: " parents)))

        ;; if parent is a symbol, evaluate it; should evaluate to a list of expansions (which might also be symbols, etc).

         (log/debug (str "overh: " (get-in parent [:rule]) " -> " (get-in head [:rule]
                                                                        (get-in head [:synsem :sem :pred]
                                                                                "(no pred for head)"))))
         (log/trace (str "overh successful result: " (strip-refs (dissoc result :dag_unify.core/serialized))))
         (list result))))))

;; Haskell-looking signature:
