prn (#765)

Author: borkdude

CHANGELOG.md

@@ -5,6 +5,8 @@
 ## Unreleased
 
 - Fix [#758](https://github.com/squint-cljs/squint/issues/758): `volatile!`, `vswap!`, `vreset!`
+- `pr-str`, `prn` etc now print EDN (with the idea that you can paste it back into your program)
+- new `#js/map` reader that reads a JavaScript `Map` from a Clojure map (maps are printed like this with `pr-str` too)
 
 ## v0.9.178
 

README.md

@@ -83,7 +83,8 @@ need the extra performance, startup time and/or small bundle size.
 - `assoc!`, `dissoc!`, `conj!`, etc. perform in place mutation on objects
 - `assoc`, `dissoc`, `conj`, etc. return a new shallow copy of objects
 - `println` is a synonym for `console.log`
-- `pr-str` and `prn` coerce values to a string using `JSON.stringify` (currently, this may change)
+- `pr-str` and `prn` print EDN with the idea that you can paste the output back into your programs
+  - JavaScript `Map`s are printed like maps with a `#js/map` prefix
 - Since JavaScript only supports strings for keys in maps, any data structures used as keys will be stringified
 
 If you are looking for closer ClojureScript semantics, take a look at [Cherry 🍒](https://github.com/squint-cljs/cherry).

src/squint/compiler.cljc

@@ -16,7 +16,7 @@
    [squint.compiler-common :as cc :refer [#?(:cljs Exception)
                                           #?(:cljs format)
                                           *aliases* *cljs-ns* *excluded-core-vars* *imported-vars* *public-vars*
-                                          comma-list emit emit-args emit-infix emit-return escape-jsx
+                                          emit emit-args emit-infix emit-return escape-jsx
                                           expr-env infix-operator? prefix-unary? suffix-unary?]]
    [squint.defclass :as defclass]
    [squint.internal.deftype :as deftype]
@@ -44,9 +44,11 @@
                          ;; prefixed to avoid conflicts
                          'squint-compiler-jsx
                          'squint-compiler-html
+                         'squint-compiler-js-map
                          'require 'squint.defclass/defclass* 'squint.defclass/super*
                          'squint.impl/for-of
-                         'squint.impl/defonce]))
+                         'squint.impl/defonce
+                         ]))
 
 (def built-in-macros (merge {'-> macros/core->
                              '->> macros/core->>
@@ -337,19 +339,26 @@
 (defn html [form]
   (list 'squint-compiler-html form))
 
+(defn js-map [form]
+  (list 'squint-compiler-js-map form))
+
 (defmethod emit-special 'squint-compiler-jsx [_ env [_ form]]
   (set! *jsx* true)
   (let [env (assoc env :jsx true)]
     (emit form env)))
 
+(defmethod emit-special 'squint-compiler-js-map [_ env [_ form]]
+  (emit (list 'new 'js/Map (mapv (fn [kv] kv) form)) env))
+
 (def squint-parse-opts
   (e/normalize-opts
    {:all true
     :end-location false
     :location? seq?
     :readers {'js #(vary-meta % assoc ::js true)
               'jsx jsx
-              'html html}
+              'html html
+              'js/map js-map}
     :read-cond :allow
     :features #{:squint :cljs}}))
 

src/squint/core.js

@@ -980,33 +980,6 @@ export function nil_QMARK_(v) {
 
 export const PROTOCOL_SENTINEL = {};
 
-function pr_str_1(x) {
-  if (x === null) {
-    return 'null';
-  }
-  return JSON.stringify(x, (_key, value) => {
-    switch (typeConst(value)) {
-      case SET_TYPE:
-      case LAZY_ITERABLE_TYPE:
-        return [...value];
-      case MAP_TYPE:
-        return Object.fromEntries(value);
-      default: {
-        // console.log(value);
-        return value;
-      }
-    }
-  });
-}
-
-export function pr_str(...xs) {
-  return xs.map(pr_str_1).join(' ');
-}
-
-export function prn(...xs) {
-  println(pr_str(...xs));
-}
-
 export class Atom {
   constructor(init) {
     this.val = init;
@@ -2995,3 +2968,45 @@ export function volatile_BANG_(x) {
 export function vreset_BANG_(vol, v) {
   vol.v = v;
 }
+
+function toEDN(value, seen = new WeakSet()) {
+  if (value === null) return 'nil';
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'bigint') return `${value}N`;
+
+  if (typeof value === 'object') {
+    if (seen.has(value)) return '#object[circular]';
+    seen.add(value);
+    const T = typeConst(value);
+    let keys;
+    switch (T) {
+      case ARRAY_TYPE:
+        return `[${value.map((v) => toEDN(v, seen)).join(' ')}]`;
+      case SET_TYPE:
+        return `#{${Array.from(value)
+          .map((v) => toEDN(v, seen))
+          .join(' ')}}`;
+      case MAP_TYPE:
+        return `#js/map {${Array.from(value.entries())
+          .map(([k, v]) => `${toEDN(k, seen)} ${toEDN(v, seen)}`)
+          .join(', ')}}`;
+      case LAZY_ITERABLE_TYPE:
+      case LIST_TYPE:
+        return `(${mapv((v) => `${toEDN(v, seen)}`, value).join(', ')})`;
+      default:
+        keys = Object.keys(value);
+        return `{${keys.map((k) => `:${k} ${toEDN(value[k], seen)}`).join(', ')}}`;
+    }
+  }
+
+  return `#object[${value.constructor.name}]`;
+}
+
+export function pr_str(...xs) {
+  return xs.map((v, _) => toEDN(v)).join(' ');
+}
+
+export function prn(...xs) {
+  return console.log(pr_str(...xs));
+}

test/squint/compiler_test.cljs

@@ -657,7 +657,9 @@
   (is (eq "hello/world" (jsv! "(ns hello) ::world"))))
 
 (deftest pr-str-test
-  (is (eq (js/Set. #js ["a" "b" "c"]) (js/Set. (js/JSON.parse (jsv! '(pr-str #{:a :b :c})))))))
+  (doseq [coll [#{"a" "b" "c"} {:a 1 :b 2}]]
+    (is (eq (pr-str coll) (jsv! `(pr-str ~coll)))))
+  (is (eq "#js/map {\"a\" 1}" (jsv! "(pr-str #js/map {:a 1})"))))
 
 (deftest str-test
   (is (eq "123" (jsv! '(str 1 2 3))))
@@ -2007,7 +2009,7 @@ globalThis.foo.fs = fs;")))))
       (fs/mkdirSync "test-output"))
     (fs/writeFileSync "test-output/foo.mjs" js)
     (is (str/includes? (process/execSync "node test-output/foo.mjs")
-                       "[[-1,-2,-3],true,-10]"))))
+                       "[[-1 -2 -3] true -10]"))))
 
 (deftest pre-post-test
   (testing "pre"