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

        (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: "

                                                        (truncate parent [[:comp]
                                                                          [:head]]
                                                                  model)))
                                                  trees))]
                                       (if (not (empty? trees))
                                         (log/debug (str "parse/parses: trees: "
                                                         (string/join ","
                                                                      (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-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)])]))
