basilisp.io namespace (#645)

* basilisp.io namespace

* Text text text

* Add input-stream and output-stream

* writable

* Use the existing mode

* Fix the thing

* Changelog

* Not the right place for optimizations

* Fun juice

* Simpler test init

* More stuff and also tests

* Unused import

* Fix missing paren

* Documint

* Tests r gud

* Additional reader tests

* More tests

* input-stream tests

* output stream test

* Copy impl

* copy tests

* C o p y

* Comments

* Sure

* Lol

Author: chrisrink10

CHANGELOG.md

@@ -11,11 +11,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Added support for Taps (#631)
  * Added support for hierarchies (#633)
  * Added support for several more utility Namespace and Var utility functions (#636)
+ * Added `basilisp.io` namespace with polymorphic reader and writer functions (#645)
 
 ### Changed
  * PyTest is now an optional extra dependency, rather than a required dependency (#622)
  * Generated Python functions corresponding to nested functions are now prefixed with the containing function name, if one exists (#632)
  * `basilisp.test/are` docstring now indicates that line numbers may be suppressed on assertion failures created using `are` (#643)
+ * Multimethods now support providing a custom hierarchy and dispatch to registered values using `isa?` (#644)
 
 ### Fixed
  * Fixed a bug where `seq`ing co-recursive lazy sequences would cause a stack overflow (#632)

src/basilisp/core.lpy

@@ -1500,6 +1500,17 @@
       (throw
        (python/ValueError (str "cannot coerce " (python/repr x) " to byte"))))))
 
+(defn byte-string
+  "Coerce x to a byte string (Python `bytes` object).
+
+  Arguments shall be interpreted exactly as with that object's constructor."
+  ([x]
+   (python/bytes x))
+  ([x encoding]
+   (python/bytes x encoding))
+  ([x encoding errors]
+   (python/bytes x encoding errors)))
+
 (defn char
   "Coerce x to a string of length 1.
 
@@ -4937,7 +4948,15 @@
             (vector? parent)
             (->> (map (partial isa? h) tag parent)
                  (every? identity)))
-       (contains? (ancestors h tag) parent))))
+       (contains? (ancestors h tag) parent)
+       ;; in certain cases, in particular with the Python `io` module, the types
+       ;; in a class's MRO are not identical to the types users have access to.
+       ;; this is likely the case due to so-called "virtual" subclasses such as
+       ;; those supported by Python's `abc` module. we need to use `issubclass`
+       ;; to detect those edge cases.
+       (and (instance? python/type tag)
+            (instance? python/type parent)
+            (python/issubclass tag parent)))))
 
 (defn derive
   "Derive a parent/child relationship between `tag` and `parent`.
@@ -6425,6 +6444,53 @@
 
        ~type-name)))
 
+;;;;;;;;;;;;;;;;;;
+;; IO Utilities ;;
+;;;;;;;;;;;;;;;;;;
+
+;; This is a circular import since namespaces using 'ns will always try to refer all
+;; symbols from 'basilisp.core. This should be fine since we won't be using anything
+;; from core defined below this section, but still this is a bad pattern and should
+;; not be replicated.
+(require 'basilisp.io)
+
+(defn slurp
+  "Open a `basilisp.io/reader` instance on `f` and read the contents of `f` into a
+  string.
+
+  Options may be provided as key value pairs and will be passed directly to
+  `basilisp.io/reader`. Supported reader options depend on which type of reader is
+  selected for `f`. Most readers support the `:encoding` option.
+
+  If `f` is a string, it first is resolved as a URL (via `urllib.parse.urlparse`).
+  If the URL is invalid or refers to a filesystem location (via `file://` scheme),
+  then it will be resolved as a local filesystem path.
+
+  Return the string contents."
+  [f & opts]
+  (with-open [reader (apply basilisp.io/reader f opts)]
+    (.read reader)))
+
+(defn spit
+  "Open a `basilisp.io/writer` instance on `f` and write `content` out to `f` before
+  closing the writer.
+
+  Options may be provided as key value pairs and will be passed directly to
+  `basilisp.io/writer`. Supported writer options depend on which type of writer is
+  selected for `f`. Most writers support the `:encoding` option.
+
+  If `f` is a string, it first is resolved as a URL (via `urllib.parse.urlparse`).
+  If the URL is invalid or refers to a filesystem location (via `file://` scheme),
+  then it will be resolved as a local filesystem path.
+
+  `spit` does not support writing to non-file URLs.
+
+  Return `nil`."
+  [f content & opts]
+  (with-open [writer (apply basilisp.io/writer f opts)]
+    (.write writer content)
+    nil))
+
 ;;;;;;;;;;;;;;;;;
 ;; Transducers ;;
 ;;;;;;;;;;;;;;;;;