             (get @(:rules-for-spec model) plain-spec ::none))]
       (if (not (= ::none looked-up))
         looked-up
-        (let [matching-rules (matching-rules spec model)]
+        (let [matching-rules (matching-rules spec)]
           (swap! (:rules-for-spec model) #(assoc % plain-spec matching-rules))
           matching-rules)))))
       
 (defn parent-with-head
   "Return every possible tree of depth 1 from the given spec and model."
-  [spec model depth]
+  [spec depth]
   ;; get all rules that match input _spec_:
   (if (nil? spec) (throw (Exception. (str "nope: spec was nil."))))
   (let [matching-rules
-        (shuffle (rules-for-spec spec model))]
+        (shuffle (rules-for-spec spec))]
     (->> matching-rules
          (map #(unify % spec))
          (filter #(not (= :fail %)))
          ;; 2. try to add heads to each matching rule:
-         (parent-with-head-1 spec model depth)
+         (parent-with-head-1 spec depth)
          (filter #(not (= % :fail)))
          (map #(u/assoc-in! % [::started?] true)))))
 
-(defn parent-with-head-1 [spec model depth parent-rules]
+(defn parent-with-head-1 [spec depth parent-rules]
   (if (not (empty? parent-rules))
     (let [parent-rule (first parent-rules)
           phrases-with-phrasal-head #(map (fn [child]

                  
                  true ;; generate children that are leaves before children that are trees.
                  (lazy-cat (child-lexemes) (child-trees)))]
            (assoc-children tree children f model))
          model)
         [tree])
       (grow (rest trees) model)))))


          f (frontier tree)
          depth (count f)
          child-spec (u/get-in tree f)
          child-lexemes #(get-lexemes child-spec)
          child-trees #(parent-with-head child-spec depth)]
      (when println? (println (str "grow at:" ((:morph-ps model) tree))))
      (log/debug (str "grow at:" ((:morph-ps model) tree)))
      (lazy-cat
