                   "; right: " (vec (set (map morph right)))))
 
   (log/debug (str "over: rules: " (string/join ","
-                                               (map :rule grammar))))
-  (over/over grammar left right))
+                                               (map :rule grammar)) " with default-fn:" default-fn))
+  (if default-fn
+    (->>
+     (over/over grammar left right)
+     (map default-fn))
+    (over/over grammar left right)))
 
 (defn square-cross-product [x]
   (mapcat (fn [each-x]

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

                                                        (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)])]))
