     :reader-literal-prefix (p/unspaced open-reader-literal :symbol)
     :reader-literal [:reader-literal-prefix :expr]
     :symbol
-;      #"(?:[\-\+](?![0-9])[^\^\(^\[^\#^\{^\\^\"^\~^\%^\:^\,^\s^\;^\@^\`^\)^\]^\}]*)|(?:[^\^\(\[^\#\{\\\"\~\%\:\,\s\;\'\@\`\)\]\}\-\+;0-9][^\^\(\[\#\{\\\"\~\%\:\,\s\;\@\`\)\]\}]*|#(?![\{\(\'\^\"\_\!])[^\^\(\[\#\{\\\"\~\%\:\,\s\;\'\@\`\)\]\}]*)#?"
       #"(?:(?:[\-\+](?![0-9])[^\^\(^\[^\#^\{^\\^\"^\~^\%^\:^\,^\s^\;^\@^\`^\)^\]^\}]*)|(?:[^\^\(\[^\#\{\\\"\~\%\:\,\s\;\'\@\`\)\]\}\-\+;0-9][^\^\(\[\#\{\\\"\~\%\:\,\s\;\@\`\)\]\}]*))#?"
     :keyword (p/unspaced open-keyword #"[^\(\[\{\'\^\@\`\~\"\\\,\s\;\)\]\}]*"); factorize with symbol
     :int #"(?:[-+]?(?:0(?!\.)|[1-9][0-9]*+(?!\.)|0[xX][0-9A-Fa-f]+(?!\.)|0[0-7]+(?!\.)|[1-9][0-9]?[rR][0-9A-Za-z]+(?!\.)|0[0-9]+(?!\.))(?!/))"

      (= :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

    (= :map t) (balanced :open :close-map abstract-children)
    (= :set t) (balanced :open :close-set abstract-children)
    (= :quote t) (unbalanced :open abstract-children)
    (#{:meta :deprecated-meta} t)
      (let [[meta & rest] abstract-children]
        (concat (token :meta (node-count meta))
                (mapcat identity (view-children-seq tokens-view rest)))) 
    (= :reader-literal t) (let [body (peek abstract-children)]
                            (concat (token :reader-literal (- count (node-count body)))
                                    (body tokens-view)))
    (= :deref t) (unbalanced :open-deref abstract-children)
    (= :syntax-quote t) (unbalanced :open abstract-children) 
    (= :var t) (unbalanced :open-var abstract-children)
