2

Pretty-printing this map comes out pretty ugly:

  {:type :move,
   :name :boost,
   :from
   {:nodeid :plus,
    :name :left-operand,
    :value
    {:args [:result :right-operand],
     :f
     #object[fargish.workspace_test$fn__159675$fn__159678 0xb3f518f "fargish.workspace_test$fn__159675$fn__159678@b3f518f"]},
    :dockclass :input,
    :ref [:plus :left-operand]},
   :to
   {:nodeid :source11,
    :name :output,
    :value 11,
    :dockclass :output,
    :ref [:source11 :output]},
   :do
   #object[fargish.workspace$do_boost 0x179d226e "fargish.workspace$do_boost@179d226e"],
   :do-hypothetically
   #object[fargish.workspace$do_hypothetical_boost 0x68d6475a "fargish.workspace$do_hypothetical_boost@68d6475a"]}

Most of the time, I don't need to see most of that. I'd like it to look something roughly like this:

#boost{:from [:plus :left-operand] :to [:source11 :output]}

Does Clojure provide a hook to let me insert code so that if the value of a map's :type key is :move, str will call a function I write to generate the string?

I've looked into print-method. If I understand it correctly, that would extend a multimethod that dispatches on the type of the argument, viz. clojure.lang.PersistentArrayMap, not the :type of the map. AFAIK, there's no way to "forward" to the previously defined multimethod, or else I could write a print-method for clojure.lang.PersistentArrayMap that looked at :type and then called the generic method if its value isn't :move.

Even just customizing pprint would be helpful. Theoretically, pprint is very customizable, but I haven't found documentation that explains how. This is incomplete and suggests that pprint isn't really done.

Affecting the output of pprint would be nice but it isn't strictly necessary. Just being able to affect str and print would be a great help.

Ben Kovitz
  • 4,920
  • 1
  • 22
  • 50

2 Answers2

3

print-method already looks at the :type key on the metadata of your object. Just arrange for :type to be in the metadata rather than (or in addition to) the actual map itself, and you can define your own print-method.

amalloy
  • 89,153
  • 8
  • 140
  • 205
  • I'm afraid you are on your own with pprint. It is not used nearly as much as the core printing facilities, and my belief is that because of this it is not as flexible: fewer people care about extending it. I think the best you can do is: define a new kind of pprint dispatch method to use instead of simple-dispatch, implement whatever custom stuff you want on your-dispatch, and then delegate other decisions to simple-dispatch. But it's not nearly as easy as with print-method, because it doesn't consider metadata by default. – amalloy Mar 21 '17 at 17:21
  • You should write this answer then. The OP explicitly asked about pprint. – Leon Grapenthin Mar 21 '17 at 18:08
  • Wow, it works! Easily, even! (@LeonGrapenthin asked my next question.) Thanks. – Ben Kovitz Mar 21 '17 at 18:09
  • @LeonGrapenthin I'll clarify the question. I'm happy being able to modify print's behavior. pprint would be nice, too, but it's not absolutely necessary. – Ben Kovitz Mar 21 '17 at 18:13
  • @BenKovitz If you find my suggestions about extending pprint helpful, and they resolve your question, you should add an answer of your own explaining the details of how to extend pprint. What I said was quite handwavy and not terribly useful to anyone else who might read this question in the future. (or if you meant that my suggestion of extending print-method works easily and is sufficient, and you didn't extend pprint at all, then never mind that and just accept my answer). – amalloy Mar 21 '17 at 18:54
2

There is a pretty printing package called zprint which you can use that will get you very close to what you want, and still get you the benefits of pretty printing when your output is large and hard to visually comprehend. I've given some examples below:

; Basic zprint pretty-print of a similar map.  Note that it orders the keys
; alphabetically

user=> (zprint soq)
{:do #<Fn@4d0e1990 clojure.lang.PersistentList/Primordial>,
 :do-hypothetically #<Fn@4d0e1990 clojure.lang.PersistentList/Primordial>,
 :from {:dockclass :input,
        :name :left-operand,
        :nodeid :plus,
        :ref [:plus :left-operand],
        :value {:args [:result :right-operand],
                :f #<Fn@4d0e1990 clojure.lang.PersistentList/Primordial>}},
 :name :boost,
 :to {:dockclass :output,
      :name :output,
      :nodeid :source11,
      :ref [:source11 :output],
      :value 11},
 :type :move}

; You can order the keys so the ones you care about come in the order
; you want.

user=> (zprint soq {:map {:key-order [:name :from :to]}})
{:name :boost,
 :from {:name :left-operand,
        :dockclass :input,
        :nodeid :plus,
        :ref [:plus :left-operand],
        :value {:args [:result :right-operand],
                :f #<Fn@4d0e1990 clojure.lang.PersistentList/Primordial>}},
 :to {:name :output,
      :dockclass :output,
      :nodeid :source11,
      :ref [:source11 :output],
      :value 11},
 :do #<Fn@4d0e1990 clojure.lang.PersistentList/Primordial>,
 :do-hypothetically #<Fn@4d0e1990 clojure.lang.PersistentList/Primordial>,
 :type :move}

; You can get zprint to ignore keys completely

user=> (zprint soq {:map {:key-order [:name :from :to] :key-ignore-silent [[:from :name] :dockclass :nodeid :value :do :do-hypothetically :type [:to :name]]}})
{:name :boost,
 :from {:ref [:plus :left-operand]},
 :to {:ref [:source11 :output]}}

; You can configure zprint to do this all the time

user=> (zprint.core/set-options! {:map {:key-order [:name :from :to] :key-ignore-silent [[:from :name] :dockclass :nodeid :value :do :do-hypothetically :type [:to :name]]}})

; Now you just zprint it...

user=> (zprint soq)
{:name :boost,
 :from {:ref [:plus :left-operand]},
 :to {:ref [:source11 :output]}}

You can configure zprint with a ~/.zprintrc file to do this all the time.

You can also use czprint to get it colored, and you can color the keys any way you want too with a :key-color map. I find this useful when I look at a whole sequence of maps -- changing the color of one key and ordering the keys in the way I want allows me to comprehend a sequence of maps much more easily.

It would be simple to build a function to look at the :type and then call zprint with whatever options were appropriate for that type. Of course, the :ref is still in there, but the tradeoff comes when you have a lot of output, and the zprint pretty printing kicks in and it is just easier to read and understand.

Kim Kinnear
  • 86
  • 1