Readability of single-clause with statements

Chat / Discussions
,
1

Apparently Credo considers single-clause with statements with an else branch a readability issue. I’m curious, what’s everybody’s opinion on this?

I think with can actually help readability when implementing a function with a “happy path”:

with {:ok, yay} <- something() do
  this_is_the_happy_path(yay)
else
  {:error, reason} -> handle_error(reason)
end

The alternative is, of course, to use good ol’ case:

case something() do
  {:ok, yay} ->
    this_is_the_happy_path(yay)

  {:error, reason} ->
    handle_error(reason)
end

Which option do you find more readable?

2 Likes
2

Personal $0.02: For single clauses the case is 100% better because the patterns all line line up and stand out better.

6 Likes
3

I would say more like 90% better just because I can appreciate a possible style guide that mandates with statements for consistent error handling. So that way you can easily identify functions that can return an error versus those that just return values that trigger conditional flow.

2 Likes
4

I prefer the case as well, it’s much more natural (in the sense that even without knowing programming you would more likely be able to make sense of it) :smiley:

1 Like
5

Funnily enough. The same topic popped in recently when we were upgrading a quite old credo version.
We decided to get rid of the rule.

For me, it depends.

We have a bunch of modules where all the functions are pipelines and only one of them had a single case:

defmodule A do
  def a do
    with {:ok, a} <- do_a(),
      {:ok, b} <- do_b() do
      {:ok, b}
    end
  end

  def b do
    with {:ok, c} <- do_c(),
      {:ok, d} <- do_d() do
      {:ok, d}
    end
  end

  def c do
    with {:ok, e} <- do_e() do
      {:ok, e}
    end
  end
end

The rule that a single-case with statement should always be rewritten to case did not make much sense in that scenario. Other than consistency, I always pitch for using the simplest tool for the job. Case is simpler than with.

1 Like
6

Yes, if there is no else I use with but a single with/else should be a case in my mind.

7

I’ve seen matching in the success case work fairly well. So, your:

with {:ok, yay} <- something() do
  this_is_the_happy_path(yay)
else
  {:error, reason} -> handle_error(reason)
end

would become:

with {:ok, yay} <- something(),
     {:ok, _} = success <- this_is_the_happy_path(yay) do
    # do something here, usually log, maybe increment metrics
    success
else
  {:error, reason} -> handle_error(reason)
end
1 Like
8

I agree with your case, I would also change credo rules. In my opinion credo is a universal tool, for beginners they should follow guidelines from default config, for advanced users they should tailor the rules for their needs. Credo saved me countless times when I was working with newbies, instead of me personally telling them when to use if or case or when, credo would guide them into a decent style, from there I could explain them the things that credo didn’t cover.

1 Like