defn rules applied to Java instance methods (zprint-1.2.8)

[jcf]

I have an interesting issue where it appears rules from my "defn" are applied to lists containing instance methods.

{:fn-map {"defmacro"  [:arg1-force-nl-body {:list {:indent-arg 2}}]
          "defn"      "defmacro"
          "defn-"     "defmacro"}
 :list   {:indent-arg 1}}

Full .zprint.edn

{:extend {:flow? true :indent 0 :nl-separator? true}
 :fn-map {"->"        :none
          "->>"       :none
          "apply"     :none
          "are"       [:none
                       {:list       {:indent-only? true}
                        :next-inner {:list {:indent-only? false}}}]
          "assoc"     :none
          "defmacro"  [:arg1-force-nl-body {:list {:indent-arg 2}}]
          "defn"      "defmacro"
          "defn-"     "defmacro"
          "do"        :flow-body
          "filter"    :none
          "filterv"   :none
          "map"       :none
          "mapv"      :none
          "reduce"    :none
          "remove"    :none
          "s/cat"     [:binding {:binding {:force-nl? false}}]
          "s/fdef"    :arg1-force-nl
          "testing"   :arg1-force-nl
          "with-meta" :none-body}
 :list   {:indent-arg 1}
 :map    {:comma?        false
          :indent        0
          :key-order     [:keys :as :or]
          :sort-in-code? true
          :sort?         true}
 :pair   {:indent 0}
 :set    {:sort-in-code? true :sort? true}
 :style  [:how-to-ns :justified-original :respect-bl-off :respect-nl-off]
 :width  80}

The code below is extracted from a single file, where I copied the .addShutdownHook snippet up to the top-level to test the unexpected behaviour. You can see the result of applying the same configuration to the same code in two different places below.

;; This is formatted as expected
(.addShutdownHook
 (Runtime/getRuntime)
 (Thread. ^Runnable
          (fn []
            (try (.delete (nrepl-port-file)) (catch Exception _))
            (measure/dev
             {:bind bind :msg "Shutting down nREPL server..." :port port})
            (nrepl/stop-server server))))

(defn -main
  [& args]
  (let [{:keys [bind help? port]} (parse-args args)]
    (if help?
      (do
        (.println *err*
                  (cli/format-opts {:order [:bind :port :help]
                                    :spec  args-spec}))
        (System/exit 1))
      (let [server (nrepl/start-server :bind    bind
                                       :port    port
                                       :handler (make-nrepl-handler))]
        (spit (nrepl-port-file) (str port))
        (measure/dev {:bind bind :msg "nREPL server started!" :port port})
        ;; The exact same code here is formatted with additional indentation
        (.addShutdownHook
          (Runtime/getRuntime)
          (Thread. ^Runnable
                   (fn []
                     (try (.delete (nrepl-port-file)) (catch Exception _))
                     (measure/dev {:bind bind
                                   :msg  "Shutting down nREPL server..."
                                   :port port})
                     (nrepl/stop-server server))))
        server))))

If I remove the "defn" entry from :fn-map the .addShutdownHook sexp is indented with a single space, just as I want. Just to clariy, the same code with the same formating rules is being formatted differently based on location in the file.

This is with zprint-1.2.8.

[kkinnear]

Thanks for asking. The problem here is that in your :fn-map entry for defn (via defmacro) you have told zprint two things:

1. Use :arg1-force-nl-body for zprint, so it will see defn (et. al.) as a "body" function, and indent the later elements of the defn with {:list {:indent n}} spaces. Since you haven't changed {:list {:indent 2}}, the default, the value will be two.
2. You have also told zprint to use {:list {:indent-arg 2}} for all lists encountered when processing a defn, which completely replaces the {:list {:indent-arg 1}} which you have configured at the top level of the option map.

Because of number 2 above, there is no difference between "body" functions and "argument" functions when inside a defn. This is why your "argument" function is handled differently. Nothing is special about .addShutDownHook other than the fact that it is the only "non-body" function that has its arguments flow instead of hang. All of the other functions where the arguments flow are "body" functions. If any of the other "argument" functions were to have their arguments flow, you would also see them have two spaces for their indent.

The real question here is: what did you intend by the {:list {:indent-arg 2}} in the :fn-map for defn (and defmacro and defn-)? What did problem were you trying to solve with that addition to the :fn-map? If you can answer that, and show me what you get without it and what you wanted to get, I expect that I can come up with something to get you what you want without messing up the indents of all of the "argument" functions in every defn.

Thank you for the entire options map. As an aside, there is no need for :respect-bl-off or :respect-nl-off in the :style invocation. These are both off by default. Those styles are there because there was some situation where they were on for a while and somewhere in the :fn-map then needed to be turned off. They aren't necessary or useful except in very special cases which you don't have.

So, let me know what you were trying to accomplish, and we'll figure it out.

I'm still pondering the examples/documentation thing you proposed. I hope to respond to that tomorrow or Monday.

Thanks for asking!

[jcf]

Ahh, I see!

What I want is for my defn and defmacro forms to be consistent with and without a docstring:

(defmacro foo
  []
  ;; snip
  )

(defn bar
  []
  ;; snip
  )

(defn baz
  "Frobnicate the schnozwanger."
  []
  ;; snip
  )

[kkinnear]

Thanks for the explanation. I'm sitting here saying "but, but, it does that already". So I'm probably still not getting some aspect of this that is obvious to you but not to me. I have assumed that the above example is what you want and is "consistent" in the way you want. If that is not what you want, then that would explain my confusion.

Anyway, here is what I get when I use your example and your option map (slightly changed).

Here is your options map with the :list {:indent-arg 2} removed from the :fn-map for defmacro (and thus defn and defn-):

(czprint i309c-om)
{:extend {:flow? true, :indent 0, :nl-separator? true},
 :fn-map {"->" :none,
          "->>" :none,
          "apply" :none,
          "are" [:none
                 {:list {:indent-only? true},
                  :next-inner {:list {:indent-only? false}}}],
          "assoc" :none,
          "defmacro" :arg1-force-nl-body,
          "defn" "defmacro",
          "defn-" "defmacro",
          "do" :flow-body,
          "filter" :none,
          "filterv" :none,
          "map" :none,
          "mapv" :none,
          "reduce" :none,
          "remove" :none,
          "s/cat" [:binding {:binding {:force-nl? false}}],
          "s/fdef" :arg1-force-nl,
          "testing" :arg1-force-nl,
          "with-meta" :none-body},
 :list {:indent-arg 1},
 :map {:comma? false,
       :indent 0,
       :key-order [:keys :as :or],
       :sort-in-code? true,
       :sort? true},
 :pair {:indent 0},
 :set {:sort-in-code? true, :sort? true},
 :style [:how-to-ns :justified-original :respect-bl-off :respect-nl-off],
 :width 80}

Here is zprint formatting your example(s) with a small addition:

 (print (zprint-file-str i309a "x" i309c-om))
(defmacro foo
  []
  ;; snip
)

(defn bar
  []
  ;; snip
)

(defn baz
  "Frobnicate the schnozwanger."
  []
  (comment
    snip))

(defn stuff
  [x]
  (list x))

Whether or not they have a doc-string, they come out the same. As least they are the same to me. The final ) in the first two are because the last thing in the s-expression is a comment, which isn't common. There is a long story about why that happens, but I suspect you don't need to hear it because you (hopefully) don't end your function definitions with comments as the last thing.

Anyway, you said you wanted the formatting to be consistent whether or not there was a docstring. Which it seems to me that it is. So there is probably something important which I am missing. I'd be interested in some more details when you have a chance. Thanks.

[jcf]

Thank you, @kkinnear! I'll give that configuration a try.

Hopefully, the edge case of comments and closing parentheses will never come up.

Update: I've dropped the provided configuration into a project, and my function and macro definitions look as consistent as they are beautiful!

Thanks again, @kkinnear. Not on to sorting namespaces. :)