read

;; See one of the examples for clojure.core/pr for some uncommon Clojure values
;; that cannot be printed then read back to get the original values (or in
;; some cases, cannot be read back at all).

;; If you wish to transmit data that may contain such values, one suggestion
;; is to use the transit library: https://github.com/cognitect/transit-format

;; Note that it is not possible to pass the result of (clojure.java.io/reader) 
;; directly to (clojure.edn/read):
(require '[clojure.java.io :as io] '[clojure.edn :as edn])
=> nil
(edn/read (io/reader (.getBytes ":edn")))
ClassCastException java.io.BufferedReader cannot be cast to java.io.PushbackReader

;; Instead, you need to construct a java.io.PushbackReader instance
;; and pass that to (edn/read):
(edn/read (java.io.PushbackReader. (io/reader (.getBytes ":edn"))))
=> :edn

;; If you need to distinguish between I/O errors (permission denied, etc)
;; and syntax errors in the EDN itself (eg, unbalanced parentheses), you'll
;; want to catch different exceptions from (edn/read):

(defn load-edn
  "Load edn from an io/reader source (filename or io/resource)."
  [source]
  (try
    (with-open [r (io/reader source)]
      (edn/read (java.io.PushbackReader. r)))

    (catch java.io.IOException e
      (printf "Couldn't open '%s': %s\n" source (.getMessage e)))
    (catch RuntimeException e
      (printf "Error parsing edn file '%s': %s\n" source (.getMessage e)))))

;; At some point you'll want to serialize and deserialize java.time.LocalDate.
;; Here's how:

(defn localdate-rdr
  "Takes serialized Java object, tests for LocalDate, and returns LocalDate object."
  [[clazz _ object-string :as input]] ;; [java.time.LocalDate 861096493 "2021-04-22"]
  (if (= 'java.time.LocalDate clazz)
      ;; LocalDate string will be of form yyyy-mm-dd
      ;; which also matches the parse function.
      (java.time.LocalDate/parse object-string)
      ;; just returns input if serialized object is not LocalDate
      input))

(defn test-localdate-rdr
  []
  (let [today        (java.time.LocalDate/now)
        ;; seralized -> "#object[java.time.LocalDate 0x4479783b \"2021-04-22\"]"
        serialized   (pr-str today)
        deserialized (clojure.edn/read {:readers {'object localdate-rdr}}
                                       (java.io.PushbackReader.
                                         (java.io.StringReader. serialized)))]
  (.toString (.plusDays deserialized 1))))

user=> (test-localdate-rdr) 
"2021-04-23" ;; Today was 2021-04-22