       (= :keyword t) #{(str ":" (proposals abstract-node 1))}
       :else (let [child-views (map #(% hippie-keyword-view) abstract-children)]
               (reduce into #{} child-views)))))
-
-#_(defn nesting-level-view
-  [abstract-node t abstract-children]
-  (fn [context] 
-    (if (get nesting-tags t)
-      (inc context)
-      context)))
-
-#_(defn enhanced-tokens-view
-  [abstract-node t abstract-children]
-  (fn [context]
-    (let [new-context ((abstract-node nesting-level-view) context)
-          context-change (not= context new-context)]
-      (concat (command :nest-level new-context)
-              ((chilren-views abstract-children enhanced-tokens-view) new-context)
-              (command :nest-level context)))
-    (tokens t parse-tree-children)))
-
-#_(defn coarse-damage-view
-  [abstract-node t abstract-children]
-  (let [parse-tree-node (abstract-node parse-tree-view)
-        _               (do (println "parse-tree-node: ") parse-tree-node)
-        node-build-id (:build-id parse-tree-node)
-        offsets (mapcat (fn [child offset]
-                          (when (= node-build-id (:build-id child))
-                            [offset (+ offset (:count child))]))
-                        (:content parse-tree-node)
-                        (:content-cumulative-count parse-tree-node))]
-    (when (seq offsets) [(first offsets) (last offsets)])))
 
 (defn make-leaf [s]
   (memoized-fn abstract-leaf

    :else (token :unexpected count)))

(defn tokens-view
  ([abstract-leaf s] (do ;(print "(tokens-view) abstract-leaf:") (prn (list s)) 
                       (throw (RuntimeException. (str "argh: s='" s "'"))) (token :unexpected (.length ^String s))))
  ([abstract-node t abstract-children]
    ;(print "(tokens-view) abstract-children:") (prn abstract-children)
    (tokens t abstract-children (node-count abstract-node))))

#_(defn hippie-view
  ([abstract-leaf s] nil)
  ([abstract-node t abstract-children]
    (letfn [(proposals [abstract-node pos]
              (let [t (-> (abstract-node parse-tree-view) :content (get pos))]
                #{t (str ":" t)}))]
      (cond
        (= :symbol t) (proposals abstract-node 0) 
        (= :keyword t) (proposals abstract-node 1)
        :else (let [child-views (map #(% hippie-view) abstract-children)]
                (reduce into #{} child-views))))))

(defn- proposals [abstract-node pos]
  (-> (abstract-node parse-tree-view) :content (get pos)))

               [open-map :expr* eof]
               [open-fn :expr* eof]
               [open-set :expr* eof]
               [open-quote eof]
               [open-deref eof]
               [open-syntax-quote eof]
