 (defn comp-path-to-complements
   "return a lazy sequence of bolts for all possible complements that can be added to the end of the _path_ within _bolt_."
   [bolt path model depth max-depth]
-  (log/trace (str "comp-path-to-complements:" depth "/" max-depth ":" ((:morph-ps model) bolt) "@" path))
+  (log/info (str "comp-path-to-complements:" depth "/" max-depth ":" ((:morph-ps model) bolt) "@" path))
   (let [spec (get-in bolt path)
         lexemes (shufflefn (get-lexemes model spec))
         bolts-at (if (< depth max-depth)

     (map (fn [bolt-and-comps]
            (apply unify
                   (let [bolt (get bolt-and-comps [])
                         bolt-and-comps (dissoc bolt-and-comps [])]
                     (cons bolt
                           (->> (keys bolt-and-comps)
                                (map (fn [path]
                                       (let [result (assoc-in bolt path (get bolt-and-comps path))]
                                         (if (= true truncate)
                                           (dissoc-paths result [path])
                                           result))))))))))
     (map (fn [expression]
            (do-defaults expression model)))
     (filter not-fail?)

                                        
;; during generation, will not decend deeper than this when creating a tree:
;; TODO: should also be possible to override per-language.
(def ^:const max-total-depth 8)

;; use map or pmap.
(def ^:const mapfn map)

;; deterministic generation:
(def ^:const shufflefn (fn [x] x))

;; nondeterministic generation
;;(def ^:const shufflefn shuffle)

(def ^:const randomize-lexemes-before-phrases
  false)
;;(def ^:const randomize-lexemes-before-phrases
;;  true)

(def ^:const truncate true)

