               (log/debug (str "over: parent: " (get-in parent [:rule]) " with schema symbol: " (get-in parent [:schema-symbol])))
               (if (= (:first parent) :head)
                 ;; else, head is left child.
-                (do (log/debug "over: left child (head):" (strip-refs child1))
-                    (log/debug "over: right child (comp):" (strip-refs child2)))
+                (do (log/trace "over: left child (head):" (strip-refs child1))
+                    (log/trace "over: right child (comp):" (strip-refs child2)))
                 ;; else, head is right child.
-                (do (log/debug "over: left child (comp):" (strip-refs child1))
-                    (log/debug "over: right child (head):" (strip-refs child2))))
+                (do (log/trace "over: left child (comp):" (strip-refs child1))
+                    (log/trace "over: right child (head):" (strip-refs child2))))
 
               (concat
                ;; if parent is map, do introspection: figure out the schema from the :schema-symbol attribute,

  (when (and (map? parent)
             (map? head))
    (do
      (log/debug (str "overh: parent: " (strip-refs (dissoc parent :serialized))))
      (log/debug (str "overh: head: " (strip-refs (dissoc head :serialized))))))

  (cond


         label (if (get-in parent [:rule]) (get-in parent [:rule]) (:comment parent))]
     (if (not is-fail?)
       (do
         (log/debug (str "overh successful result: " (get-in parent [:rule])))
         (log/trace (str "overh successful result: " (strip-refs (dissoc result :serialized))))
         (list result))))))

;; Haskell-looking signature:
