             true)
            (u/dissoc-paths (if truncate? [f] []))
            ((or (:default-fn model) (fn [x] [x])))))
-     (assoc-each-default tree (rest children) f model))))
-
-(defn assoc-children [tree children f model]
+     (assoc-each-default tree (rest children) f))))
+
+(defn assoc-children [tree children f]
   (if (not (empty? children))
     (let [child (first children)
           default-fn (or (:default-fn model)
                          (fn [x] [x]))]
       (lazy-cat
        (if (= true (u/get-in child [::done?]))
-         (assoc-each-default tree (default-fn child) f model)
+         (assoc-each-default tree (default-fn child) f)
          [(u/assoc-in tree f child)])
-       (assoc-children tree (rest children) f model)))))
+       (assoc-children tree (rest children) f)))))
 
 (defn grow
   "recursively generate trees given 
    input trees and model. continue recursively
    until no futher expansion is 
    possible."
-  [trees model]
+  [trees]
   (if (not (empty? trees))
     ;; for each tree,
     ;; find the next point of 

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


         (phrases-with-lexical-heads)
         ;; 2. phrases that could be the head child:
         (phrases-with-phrasal-head)
         (parent-with-head-1 spec depth (rest parent-rules)))))))

(defn get-lexemes [spec]
  "Get lexemes matching the spec. Use a model's index if available, where the index 
   is a function that we call with _spec_ to get a set of indices. 
   Otherwise use the model's entire lexeme."
