Specify only _some_ errors to be retried.

[rafal0p]

Let's assume that we have a function like that:

  @spec foo() ::
          :ok
          | {:error, :some_retryable_reason}
          | {:error, :other_retryable_reason}
          | {:error, :some_non_retryable_reason}
          | {:error, :other_non_retryable_reason}
  def foo() do
    ...
  end

What I'd like to express is roughly this:

retry with: linear_backoff(50, 1) |> take(5),
      rescue_only: [
        {:error, :some_retryable_reason},
        {:error, :other_retryable_reason}
      ] do
  foo()
after
  _ -> :ok
else
  error -> error
end

So - for some subset of errors attempt the retry, while for others give up instantly.

Currently it is impossible:

• rescue_only works only for exceptions (foo would need to raise instead of returning {:error, reason})

• atoms is for, well... atoms, not tuples (although with this interesting exception (if the first element of 2–elements tuple is a given atom the retry will kick in)

  I can't see clear way of this situation. Some ideas:

• third option, tuples, which would match any tuples specified by the user (any length, not necessarily (:error, reason}

• allowing rescue_only to accept all sort of things, mixed - exceptions, atoms, tuples

  What are your thoughts on that?

[nathanalderson]

What if it accepted a list of patterns? I would love this for Exceptions as well. I'm willing to try a PR in that direction if interested.

[rafal0p]

Could you give an example of such API?