 
       (or (when-let [p (parse-symbol token)]
             (symbol (p 0) (p 1)))
-          (reader-error rdr "Invalid token:" token)))))
+          (reader-error rdr "Invalid token: " token)))))
 
 (defn- resolve-ns [sym]
   (or ((ns-aliases *ns*) sym)

      \" (.toString sb)
      (recur (doto sb (.append ch)) (char (read-char reader))))))

(defn- parse-symbol [^String token]
  (when (not (= "" token))
    (let [ns-idx (.indexOf token "/")
          ns (if-not (== -1 ns-idx) (.substring token 0 ns-idx))]
      (if (nil? ns)
        [nil token]
        (when-not (== (inc ns-idx) (count token))
          (let [sym (.substring token (inc ns-idx))]
            (when (and (not (numeric? (.charAt sym 0)))
                       (not (= "" sym))
                       (or (= sym "/")
                           (== -1 (.indexOf sym "/"))))
              [ns sym])))))))

(defn read-symbol
  [rdr initch]
  (when-let [token (read-token rdr initch)]

        (throw e)
        (throw (ex-info (.getCause e)
                        (merge {:type :reader-exception}
                               (if (instance? blind.reader.IndexingReader reader)
                                 {:line (get-line-number reader)
                                  :column (get-column-number reader)}))
                        e))))))
