Review, revise, or remove run-on defs

[christopheradams]

There is a rule under Source Code Layout which reads:

• ...but run single-line defs that match for the same function together.

  def some_function(nil), do: {:err, "No Value"}
  def some_function([]), do: :ok
  def some_function([first|rest]) do
    some_function(rest)
  end

I'm curious how applicable this is or if there are any edge cases or other issues or problems it causes. Should it be amended? Does anyone have counter-examples?

Thanks to @DavidAntaramian for bringing this up on another channel.

[eksperimental]

👍 to get rid of it. I'm not against it, I simply wouldn't promote it in a style guide.

[christopheradams]

I'm just noting for the record and my memory's sake that what prompted this was a slightly different issue about the desire for multi-line defs:

coverage tools like ExCoverall won’t pick up on the first two def statements because it ignores them as function declarations

In open source libs I always have multiline def statements unless i’m sure i don’t need to be notified if a line loses coverage

[DavidAntaramian]

To expand on the above, ExCoveralls in particular (which I am going to go on a limb and assume is a popular coverage tool for Elixir), declares the sequence def.+(.+\/\/.+).+do as a "stop word", so it will skip lines that match, including single-line defs.

I would say this is largely a deficiency in the coverage tool, but it raises the question of whether we can justify the run-together defs regardless.

[christopheradams]

This style is pretty common in the core libraries and other popular ones like Plug and Ecto. That would recommend keeping it, but it's good to know about issues it might cause for other tools.

Interestingly, Credo has an even more strict version of this rule: "Keep the same function with different signatures together without separating blank lines." That seems pretty rare.

Nota bene: I've edited the initial issue to not take a position.

[DavidAntaramian]

Is that where that comes from? I've seen a few people use that system where it essentially looks like:

def function(args1) do
  #logic
end
def function(args2) do
  #logic
end
def function(args3) guardclause do
  #logic
end

It's never seemed particularly helpful.

[DavidAntaramian]

We should also refer to #31 and #39 as precedent

[christopheradams]

Good find. I think as presently worded it's satisfactory then.