Force newline before function?

[agriffis]

Hi Kim,

In the codebase where I'm working, there are some functions that should always be preceded by a newline, for example:

(when errors
  (json-api/error "" :errors errors))

Is there a way to configure zprint to always insert that newline, instead of collapsing to:

(when errors (json-api/error "" :errors errors))

Thanks!

[kkinnear]

Hey Aron!

There is no way, at present, to have a function affect the formatting of the function containing it. Well, not without having every function look into what it contains and look for specific functions that needed to be proceeded by a newline. Which could be done, but it would make the configuration truly unpleasant for every function to be configured to do that.

It would be possible to have some specific functions look into what they contain and precede some functions with newlines.

Alternatively, it is very simple to have when always place its first argument on the same line (if possible) and then the remaining arguments on the next line, regardless of the next arguments and regardless of the whether it would all fit on the same line. You just put {:fn-map {"when" :arg1-force-nl-body}} in your configuration's options map.

(czprint i205 {:parse-string? true :fn-map {"when" :arg1-force-nl-body}})
(when errors
  (json-api/error "" :errors errors))

That may be overmuch change to when to handle the (json-api/error ...) case that you have, and not enough change for other places (json-api/error ...) might occur. But it is simple.

Let me know if you would like me to put together something which you could attach to some specific functions and which would check their arguments for a particular set of other functions and if any of them appeared, would cause the containing function to not format on a single line. I'm pretty sure that I could make this work with 1.1.2. It wouldn't be a lot of work, but it is enough work that if you aren't interested in that approach, I doin't want to invest the time in it.

If you are interested in something like that, it would help me to know what functions you think you might want to look into themselves for the functions which would force printing to never be on the same line, and which functions you would expect would force that "not on the same line" behavior.

I am aware that I have restated your request to be "some functions force the containing function to never format on the same line" instead of "some function force a newline before they format". I believe that my restatement will cause your original request to happen, and it is something that I think zprint can actually achieve in a reasonable way. It is possible that I could actually insert a newline before some functions, and I would look into that, but it is considerably more complex for reasons that nobody is really interested in hearing about.

[agriffis]

Thank you for the thoughtful reply, Kim.

I think if you were to make a change to 1.1.2 to enable this, the only pair that comes to mind is when/json-api/error. If it weren't too hard to do, it would save me some post-formatting effort to repair those newlines each time. But it's not keeping me from using zprint, so please don't prioritize it too much.

Considering your last sentence, I think it would eventually be neat to enable inserting a newline before some functions, when it seems reasonable to tackle that.

[kkinnear]

Aron,

So, give this a try. It is a tiny bit more complex than I had hoped, but the simple way encountered a bug (which I will fix in 1.2.0), but this should work for you in 1.1.2 that you have now.

Put this in your configuration:

{:fn-map
   {"when" [:arg1-body
            {:list {:option-fn
                      (fn ([] "(when * (json-api/error ...)) never on one line")
                          ([opts n exprs]
                           (when (and (>= n 3)
                                      (= (first (nth exprs 2)) 'json-api/error))
                             {:guide [:element :element-best :newline
                                      :element-best-*]})))},
             :next-inner {:list {:option-fn nil}}}]}}

This adds code so that whenever the when function is formatted, it looks at the third thing in the s-expression, and if the first thing in that s-expr is json-api/error, then it emits a "guide" that causes a newline to appear between the second and third things in the s-expr. I haven't yet documented "guides" for general use (since that will be a lot of work), but I created them to be able to do things like this that aren't easy to do with regular zprint configuration. (Except that this should have been easy to do with regular zprint configuration, but for a silly bug in something that I obviously never tested, sigh.)

Anyway, give that a try and see if it solves the immediate problem for you.

[agriffis]

It works! Thanks Kim!