       (log/trace (str "over-each-parent-comp: done. returning nil"))
       nil)))
 
-(defn over-each-head-child [parent children morph]
+(defn over-each-head-child [parent children]
   (log/trace (str "over-each-head-child: parent type: " (type parent)))
   (log/trace (str "over-each-head-child: head children type: " (type children)))
   (if (not (empty? children))
     (let [each-child (first children)]
       (lazy-cat
-       (overh parent each-child morph)
-       (over-each-head-child parent (rest children) morph)))
+       (overh parent each-child)
+       (over-each-head-child parent (rest children))))
     (do
       (log/trace (str "over-each-head-child: done. returning nil."))
       nil)))

     (if (not is-fail?)
       (list result)))))

(defn overhc [parent head comp & [morph]]
  (overc (overh parent head morph) comp))

;; TODO: distinguish between when:
;; 1) called with only a child1 (no child2),

   (or (set? head)
       (vector? head))
   (do (log/trace "head is a set: converting to a seq.")
       (overh parent (lazy-seq head)))

   (seq? head)
   (let [head-children head]
     (log/trace (str "head is a seq - actual type is " (type head)))
     (filter (fn [result]
               (not (fail? result)))
             (over-each-head-child parent head-children)))

   true
   ;; TODO: 'true' here assumes that both parent and head are maps: make this assumption explicit,
   ;; and save 'true' for errors.
   (let [result (moreover-head parent head sem-impl)
         is-fail? (fail? result)
         label (if (get-in parent [:rule]) (get-in parent [:rule]) (:comment parent))]
     (if (not is-fail?)
