Add support for :orchard/display-as-map meta flag

Author: alexander-yakushev

src/orchard/inspect.clj

@@ -70,7 +70,9 @@
     (string? obj) :string
     (set? obj) :set
     (instance? Map obj) :map
-    (instance? List obj) :list
+    (instance? List obj) (if (:orchard/display-as-map (meta obj))
+                           :map
+                           :list)
     (var? obj) :var
     (instance? Class obj) :class
     (instance? clojure.lang.Namespace obj) :namespace

src/orchard/inspect/analytics.clj

@@ -17,12 +17,12 @@
        (into {})))
 
 (defn- *frequencies [coll]
-  (->> coll
-       (eduction (take *size-cutoff*))
-       frequencies
-       (sort-by second >)
-       (apply concat)
-       (apply array-map)))
+  (with-meta
+    (->> coll
+         (eduction (take *size-cutoff*))
+         frequencies
+         (sort-by second >))
+    {:orchard/display-as-map true}))
 
 (definline ^:private inc-if [val condition]
   `(cond-> ~val ~condition inc))

src/orchard/pp.clj

@@ -332,15 +332,19 @@
 
   clojure.lang.ISeq
   (-pprint [this writer opts]
-    (-pprint-seq this writer opts))
+    (if (:orchard/display-as-map (meta this))
+      (-pprint-map this writer opts)
+      (-pprint-seq this writer opts)))
 
   clojure.lang.IPersistentMap
   (-pprint [this writer opts]
     (-pprint-map this writer opts))
 
   clojure.lang.IPersistentVector
   (-pprint [this writer opts]
-    (-pprint-coll this writer opts))
+    (if (:orchard/display-as-map (meta this))
+      (-pprint-map this writer opts)
+      (-pprint-coll this writer opts)))
 
   clojure.lang.IPersistentSet
   (-pprint [this writer opts]

src/orchard/print.clj

@@ -19,6 +19,13 @@
                      TruncatingStringWriter$TotalLimitExceeded))
   (:require [clojure.string :as str]))
 
+(defn- display-as-map?
+  "Special case for printing: when `:orchard/display-as-map` is present on a
+  sequence, assume it is a sequence of MapEntry objects and display it as a
+  map."
+  [x]
+  (and (instance? List x) (:orchard/display-as-map (meta x))))
+
 (defmulti print
   (fn [x _]
     (cond
@@ -32,6 +39,7 @@
       (instance? Symbol x)            :scalar
       (instance? IRecord x)           :record
       (instance? Map x)               :map
+      (display-as-map? x)             :persistent-map
       (instance? IPersistentVector x) :vector
       (instance? List x)              :list
       (instance? IPersistentSet x)    :set

test/orchard/inspect/analytics_test.clj

@@ -9,48 +9,47 @@
 
 (deftest numbers-test
   (is+ {:count 1000
-        :types {java.lang.Long 1000}
-        :frequencies map?
+        :types [[java.lang.Long 1000]]
+        :frequencies seq?
         :numbers {:n 1000, :zeros 1, :max 999, :min 0, :mean 499.5}}
        (analytics (range 1000)))
 
   (is+ {:count 100
-        :types {java.lang.Integer 50, java.lang.Long 50}
-        :frequencies {0 50, 1 50}
+        :types [[java.lang.Integer 50] [java.lang.Long 50]]
+        :frequencies [[0 50] [1 50]]
         :numbers {:n 100, :zeros 50, :max 1, :min 0, :mean 0.5}}
        (analytics (concat (map int (repeat 50 0)) (repeat 50 1))))
 
   (is+ {:count 6
-        :types {java.lang.Long 3, nil 3}
-        :frequencies {nil 3, 0 1, 1 1, 2 1}
+        :types [[java.lang.Long 3] [nil 3]]
+        :frequencies [[nil 3] [0 1] [1 1] [2 1]]
         :numbers {:n 3, :zeros 1, :max 2, :min 0, :mean 1.0}}
        (analytics [0 nil 1 nil 2 nil])))
 
 (deftest strings-test
   (is+ {:count 100
-        :types {java.lang.String 100}
-        :frequencies map?
+        :types [[java.lang.String 100]]
+        :frequencies seq?
         :strings {:n 100, :blank 0, :ascii 100, :max-len 2, :min-len 1, :avg-len (approx 1.9)}}
        (analytics (map str (range 100))))
 
   (is+ {:count 6,
-        :types {java.lang.String 5, nil 1}
-        :frequencies map?
+        :types [[java.lang.String 5] [nil 1]]
+        :frequencies seq?
         :strings {:n 5, :blank 3, :ascii 4, :max-len 6, :min-len 0, :avg-len (approx 2.8)}}
        (analytics [nil "" " " "  " "hello" "привіт"])))
 
 (deftest colls-stats
   (is+ {:count 20
-        :types {clojure.lang.LongRange 19, clojure.lang.PersistentList$EmptyList 1}
-        :frequencies map?
+        :types [[clojure.lang.LongRange 19] [clojure.lang.PersistentList$EmptyList 1]]
+        :frequencies seq?
         :collections {:n 20, :empty 1, :max-size 19, :min-size 0, :avg-size 9.5}}
        (analytics (map range (range 20)))))
 
 (deftest heterogeneous-list-stats
   (is+ {:count 90,
-        :types {java.lang.Long 20, java.lang.Integer 20, java.lang.String 20, clojure.lang.PersistentVector 20, nil 10}
-        :frequencies {nil 10, [42] 10, [] 10 ;; and others
-                      }
+        :types (mc/via #(into {} %) {java.lang.Long 20, java.lang.Integer 20, java.lang.String 20, clojure.lang.PersistentVector 20, nil 10})
+        :frequencies (mc/via #(into {} %) {nil 10, [42] 10, [] 10}) ;; and others
         :numbers {:n 40, :zeros 2, :max 19, :min 0, :mean 9.5}
         :strings {:n 20, :blank 0, :ascii 20, :max-len 2, :min-len 1, :avg-len 1.5}
         :collections {:n 20, :empty 10, :max-size 1, :min-size 0, :avg-size 0.5}}
@@ -63,22 +62,22 @@
 
 (deftest keyvals-test
   (is+ {:count 100
-        :keys {:types {java.lang.Long 100}
-               :frequencies map?
+        :keys {:types [[java.lang.Long 100]]
+               :frequencies seq?
                :numbers {:n 100, :zeros 1, :max 99, :min 0, :mean 49.5}}
-        :values {:types {java.lang.String 100}
-                 :frequencies map?
+        :values {:types [[java.lang.String 100]]
+                 :frequencies seq?
                  :strings {:n 100, :blank 0, :ascii 100, :max-len 2, :min-len 1, :avg-len (approx 1.9)}}}
        (analytics (zipmap (range 100) (map str (range 100))))))
 
 (deftest list-of-tuples-test
   (is+ {:count 100
-        :tuples [{:types {java.lang.Long 100}
+        :tuples [{:types [[java.lang.Long 100]]
                   :numbers {:n 100, :zeros 1, :max 99, :min 0, :mean 49.5}}
-                 {:types {java.lang.String 100}
+                 {:types [[java.lang.String 100]]
                   :strings {:n 100, :blank 0, :ascii 100, :max-len 2, :min-len 1, :avg-len (approx 1.9)}}
-                 {:types {nil 50, java.lang.Long 50}
-                  :frequencies {nil 50, 42 50}
+                 {:types [[nil 50] [java.lang.Long 50]]
+                  :frequencies [[nil 50] [42 50]]
                   :numbers {:n 50, :zeros 0, :max 42, :min 42, :mean 42.0}}]}
        (analytics (map #(cond-> [% (str %)]
                           (odd? %) (conj 42))
@@ -87,11 +86,11 @@
 (deftest list-of-records-test
   (testing "analytics on a list of records analyzes values for each unique key individually"
     (is+ {:count 100
-          :by-key {:s {:types {java.lang.String 100}
-                       :frequencies map?
+          :by-key {:s {:types [[java.lang.String 100]]
+                       :frequencies seq?
                        :strings {:n 100, :blank 0, :ascii 50, :max-len 7, :min-len 5, :avg-len (approx 6.4)}}
-                   :kw {:types {nil 66, clojure.lang.Keyword 34}, :frequencies {nil 66, :occasional 34}}
-                   :i {:types {java.lang.Long 100}
+                   :kw {:types [[nil 66] [clojure.lang.Keyword 34]], :frequencies [[nil 66] [:occasional 34]]}
+                   :i {:types [[java.lang.Long 100]]
                        :numbers {:n 100, :zeros 1, :max 99, :min 0, :mean 49.5}}}}
          (analytics (map #(cond-> {:i %
                                    :s (str "test" % (when (even? %) "ї"))}
@@ -122,7 +121,7 @@
            (analytics (repeat 100 [1 "test"]))))
     (is+ {:cutoff? true
           :count 100
-          :keys {:types {java.lang.Long 100}}
-          :values {:types {java.lang.Long 100}}}
+          :keys {:types [[java.lang.Long 100]]}
+          :values {:types [[java.lang.Long 100]]}}
          (binding [orchard.inspect.analytics/*size-cutoff* 100]
            (analytics (zipmap (range 200) (range 200)))))))