 (def uppercase (into #{} (char-range \A \Z)))
 (def lowercase (into #{} (char-range \a \z)))
 (def digits (into #{} (char-range \0 \9)))
-(def letters_ (clojure.set/union uppercase lowercase #{\_}))
-(def letters_digits (clojure.set/union letters_ digits))
+(def letters_ (set/union uppercase lowercase #{\_}))
+(def letters_digits (set/union letters_ digits))
 
 (def keywords
   (let [l '(and as assert break class continue

(defn char-lower-case [c]
  (when c (char (java.lang.Character/toLowerCase (int c)))))

(def char-name-chars (clojure.set/union uppercase #{\space}))

(def &named-char
  (&let

    _ (&string-end-quote long? q)]
   [:string [s long? q ub r]]))

(defn &intpart [prefix]
  (&conj (&char-if decimal-digit) prefix))

(defn &fraction [prefix]
  (&do (&char= \.) (&intpart (conj prefix \.))))

(defn &exponent [prefix]
  (&let [c (&char-if #{\e \E})
         s (&optional (&char-if #{\+ \-}))
         e (&intpart (list* s c prefix))]
        e))

(def &point-float
  (&or (&bind (&optional (&intpart ())) &fraction)
       (&let [i (&intpart ()) c (&char= \.)] (conj i c))))

(def &exponent-float
  (&bind (&or &point-float (&intpart ())) &exponent))

(def &float-literal
  (&let [x (&or &exponent-float &point-float)]
     [:float (Double/parseDouble (stringify x))]))

(def &decimal-integer
  (&chars (&char-if decimal-digit) '("10r")))

(def &octal-integer
  (&chars (&char-if octal-digit) '("8r")))

(def &hexadecimal-integer
  (&chars (&char-if hexadecimal-digit) '("16r")))

(def &binary-integer
  (&chars (&char-if #{\0 \1}) '("2r")))

(def &integer-literal
  (&let [c &peek-char
         i (cond
            (= c \0) (&bind (&do &read-char &peek-char)
                            (fn [c] (cond (#{\o \O} c) (&do &read-char &octal-integer)
                                          (#{\x \X} c) (&do &read-char &hexadecimal-integer)
                                          (#{\b \B} c) (&do &read-char &binary-integer)
                                          (octal-digit c) &octal-integer
                                          :else (&return "0"))))
            (decimal-digit c) &decimal-integer
            :else &fail)
         _ (&optional (&char-if #{\l \L}))]
    [:integer (edn/read-string i)]))

(def &numeric-literal
  (&or &float-literal &integer-literal))

(def delimiters
  '("@" "," ":" "." "`" "=" ";"
