 (defn lookup [{lookup :lookup
                lexical-cache :lexical-cache
                default-fn :default-fn} k]
-  (log/debug (str "lookup: k=" k))
   (let [pre-default
         (if (or (= false parse-with-lexical-caching)
                 (nil? lexical-cache))

  the entire tree costs about 20% time than truncating it."
  ([input model & {:keys [parse-with-truncate original-input]}]
   (let [parse-with-truncate
         (cond (= parse-with-truncate false)
               false
               true true)
         original-input (if original-input original-input input)

                                   (map (fn [i] [(nth tokens i)])
                                        token-count-range))]
             (log/debug (str "input map:" input-map))
;;             (println (str "input map:" input-map))
             (let [all-parses
                   (parses input-map token-count model
                           (span-map token-count) parse-with-truncate)
