                                                         (truncate parent [[:comp]
                                                                           [:head]]
                                                                   model)))
-                                                  parents))]
-                                       (if (not (empty? parents))
-                                         (log/debug (str "parse/parses: parents: "
+                                                  trees))]
+                                       (if (not (empty? trees))
+                                         (log/debug (str "parse/parses: trees: "
                                                          (string/join ","
-                                                                      (map #(morph-ps %) parents))))
-                                         (log/debug (str "no parents found for left/right:")))
+                                                                      (map #(morph-ps %) trees))))
+                                         (log/debug (str "no trees found for left/right:")))
                                        (log/debug (str " left: "
                                                        (string/join ","
                                                                     (map #(morph-ps %) left-signs))))
                                        (log/debug (str " right: "
                                                        (string/join ","
                                                                     (map #(morph-ps %) right-signs))))
-                                       (if parse-with-truncate truncated-parents parents)))
+                                       (if parse-with-truncate truncated-trees trees)))
                                    ;; TODO: explain why we can use (first) here for the left- and right-strings.
                                    ;; Throw an exception if (> 1 (count left-strings)) or (> 1 (count right-strings))
                                    [(string/join " " [(first left-strings) (first right-strings)])]))

        (if (= cache-value :none) nil
            cache-value)))))

(defn over [grammar left right morph]
  "opportunity for additional logging before calling the real (over)"
  (log/trace (str "parse/over: grammar size: " (count grammar)))
  (log/debug (str "parse/over: "

                                                      (:morph model))
                                           ;; fallback to (:morph model) if
                                           ;; (:morph-ps is not available)
                                           trees (over (:grammar model) left-signs right-signs morph-ps
                                                       (:default-fn model))
                                           truncated-trees
                                           (if parse-with-truncate
                                             (map-fn (fn [parent]
                                                       (conj
