Print and family functions respect value bound to *out* now (#257)

* Print and family functions respect value bound to *out* now

* Add tests for print functions

Author: chrisrink10

src/basilisp/core/__init__.lpy

@@ -171,10 +171,6 @@
 
 ;;;;;;;;;;;; full support for syntax quote begins here ;;;;;;;;;;;;
 
-(def print
-  (fn print [& args]
-    (apply builtins/print args)))
-
 (def count
   (fn count [coll]
     (try
@@ -912,6 +908,17 @@
   [pred coll]
   [(take-while pred coll) (drop-while pred coll)])
 
+(defn interpose
+  "Return a lazy sequence of elements of coll separated by sep. If
+  coll is empty, return an empty sequence."
+  [sep coll]
+  (lazy-seq
+   (when (seq coll)
+     (if (seq (rest coll))
+       (cons (first coll)
+             (cons sep (interpose sep (rest coll))))
+       (cons (first coll) nil)))))
+
 (defn cycle
   "Cycle the items in coll infinitely."
   [coll]
@@ -971,10 +978,135 @@
        (finally
          (. (var ~vvar) ~'pop-bindings)))))
 
+;;;;;;;;;;;;;;;;;;;;;;
+;; Output Utilities ;;
+;;;;;;;;;;;;;;;;;;;;;;
+
 (def ^:dynamic *in* sys/stdin)
 (def ^:dynamic *out* sys/stdout)
 (def ^:dynamic *err* sys/stderr)
 
+(def ^:dynamic *print-sep* " ")
+
+(defn repr
+  "Return the reader representation of an object."
+  [x]
+  (basilisp.lang.util/lrepr x))
+
+(defn flush
+  "Flush the buffer currently bound to *out*."
+  []
+  (.flush *out*))
+
+(defmacro with-out-str
+  "Capture the contents of text sent to *out* and return the contents as a
+  string."
+  [& body]
+  `(binding [*out* (io/StringIO)]
+     ~@body
+     (. *out* ~'getvalue)))
+
+(defn pr
+  "Print the arguments to the stream bound to *out* in a format which
+  is readable by the reader. Multiple arguments will be separated by
+  the string value bound to *print-sep* (default is an ASCII space).
+
+  Note that some dynamically created Basilisp forms (such keywords and
+  symbols) and Python objects may not be readable again."
+  ([] nil)
+  ([x]
+   (.write *out* (repr x))
+   nil)
+  ([x & args]
+   (let [stdout    *out*
+         sep       *print-sep*
+         repr-args (interpose sep (map repr args))]
+     (.write stdout (repr x))
+     (.write stdout sep)
+     (.write stdout (apply str repr-args))
+     nil)))
+
+(defn prn
+  "Same as pr, but appending a newline afterwards."
+  ([]
+   (.write *out* \newline)
+   nil)
+  ([x]
+   (let [stdout *out*]
+     (.write stdout (repr x))
+     (.write stdout \newline)
+     nil))
+  ([x & args]
+   (let [stdout    *out*
+         sep       *print-sep*
+         repr-args (interpose sep (map repr args))]
+     (.write stdout (repr x))
+     (.write stdout sep)
+     (.write stdout (apply str repr-args))
+     (.write stdout \newline)
+     nil)))
+
+(defn pr-str
+  "Return the contents of calling pr on the args as a string."
+  [& args]
+  (with-out-str
+    (apply pr args)))
+
+(defn prn-str
+  "Return the contents of calling prn on the args as a string."
+  [& args]
+  (with-out-str
+    (apply prn args)))
+
+(defn print
+  "Print the arguments to the stream bound to *out* in a format which
+  is readable by humans. Multiple arguments will be separated by
+  the string value bound to *print-sep* (default is an ASCII space)."
+  ([] (print ""))
+  ([x]
+   (.write *out* (str x))
+   nil)
+  ([x & args]
+   (let [stdout    *out*
+         sep       *print-sep*
+         repr-args (interpose sep (map str args))]
+     (.write stdout (str x))
+     (.write stdout sep)
+     (.write stdout (apply str repr-args))
+     nil)))
+
+(defn println
+  "Print the arguments to the stream bound to *out* in a format which
+  is readable by humans. Multiple arguments will be separated by
+  the string value bound to *print-sep* (default is an ASCII space)."
+  ([] (println ""))
+  ([x]
+   (let [stdout *out*]
+     (.write stdout (str x))
+     (.write stdout \newline)
+     nil))
+  ([x & args]
+   (let [stdout    *out*
+         sep       *print-sep*
+         repr-args (interpose sep (map str args))]
+     (.write stdout (str x))
+     (.write stdout sep)
+     (.write stdout (apply str repr-args))
+     (.write stdout \newline)
+     nil)))
+
+(defn print-str
+  "Return the contents of calling print on the args as a string."
+  [& args]
+  (with-out-str
+    (apply print args)))
+
+(defn println-str
+  "Return the contents of calling println on the args as a string."
+  [& args]
+  (with-out-str
+    (apply println args)))
+
 ;;;;;;;;;;;;;;;;;;;;
 ;; REPL Utilities ;;
 ;;;;;;;;;;;;;;;;;;;;

src/basilisp/lang/runtime.py

@@ -234,6 +234,7 @@ class Namespace:
       to without an alias in this namespace.
     """
     DEFAULT_IMPORTS = atom.Atom(lset.set(seq(['builtins',
+                                              'io',
                                               'operator',
                                               'sys',
                                               'basilisp.lang.atom',

tests/basilisp/core_test.py

@@ -543,6 +543,12 @@ def test_reduce_with_lazy_seq():
     assert 25 == core.reduce(core.__PLUS__, 0, core.filter_(core.odd__Q__, vec.v(1, 2, 3, 4, 5, 6, 7, 8, 9)))
 
 
+def test_interpose():
+    assert llist.List.empty() == core.interpose(",", vec.Vector.empty())
+    assert llist.l("hi") == core.interpose(",", vec.v("hi"))
+    assert llist.l("hi", ",", "there") == core.interpose(",", vec.v("hi", "there"))
+
+
 def test_comp():
     assert 1 == core.comp()(1)
     assert "hi" == core.comp()("hi")
@@ -613,6 +619,34 @@ def test_merge():
         lmap.map({kw.keyword("a"): 53}))
 
 
+def test_pr_str():
+    assert '' == core.pr_str()
+    assert '""' == core.pr_str("")
+    assert ':kw' == core.pr_str(kw.keyword('kw'))
+    assert ':hi "there" 3' == core.pr_str(kw.keyword('hi'), "there", 3)
+
+
+def test_prn_str():
+    assert '\n' == core.prn_str()
+    assert '""\n' == core.prn_str("")
+    assert ':kw\n' == core.prn_str(kw.keyword('kw'))
+    assert ':hi "there" 3\n' == core.prn_str(kw.keyword('hi'), "there", 3)
+
+
+def test_print_str():
+    assert '' == core.print_str()
+    assert '' == core.print_str("")
+    assert 'kw' == core.print_str(kw.keyword('kw'))
+    assert 'hi there 3' == core.print_str(kw.keyword('hi'), "there", 3)
+
+
+def test_println_str():
+    assert '\n' == core.println_str()
+    assert '\n' == core.println_str("")
+    assert 'kw\n' == core.println_str(kw.keyword('kw'))
+    assert 'hi there 3\n' == core.println_str(kw.keyword('hi'), "there", 3)
+
+
 def test_re_find():
     assert None is core.re_find(re.compile(r"\d+"), "abcdef")
     assert "12345" == core.re_find(re.compile(r"\d+"), "abc12345def")