Is there a way to deal with a method that ALWAYS raises?

[aaronmallen]

I'm unsure how to handle the situation where the outcome is either a thing or an error is raised. Specifically when the error is raised by a convenience method.

Take this example:

class Checker
  # @rbs (Array[untyped] thing_to_check) -> bool
  def check(thing_to_check)
    case thing_to_check.size
    when 1 then check_single(thing_to_check.first)
    when 2 then check_tuple(thing_to_check)
    when 3 then check_triple(thing_to_check)
    else raise_invalid!(thing_to_check)
    end
  end

  private

  # @rbs (untyped single) -> bool
  def check_single(single)
    return true if single.is_a?(Numeric)

    raise_invalid!(single_value)
  end

  # @rbs (Array[untyped] tuple) -> bool
  def check_tuple(tuple)
    first, second = tuple
    return true if first.is_a?(Numeric) && second == :signed

    raise_invalid!(tuple)
  end

  # @rbs (Array[untyped] triple) -> bool
  def check_triple(triple)
    first, second, third = triple
    return true if first.is_a?(Numeric) && second == :signed && third == :verified

    raise_invalid!(triple)
  end

  # @rbs (untyped invalid_value) -> void
  def raise_invalid!(invalid_value)
    raise ArgumentError, "Invalid value: #{invalid_value.inspect}"
  end
end

Obviously in this case the happy path is check returns a bool and I'd like the method to be typed as such to satisfy downstream dependencies. However steep doesn't like this at all. Steep will complain that you can't type check as bool because it potentially returns void.

My guess is I need to somehow type raise_invalid! differently here but I'm not sure how to do that outside of doing something like this:

class Checker
  # @rbs (Array[untyped] thing_to_check) -> bool
  def check(thing_to_check)
    case thing_to_check.size
    when 1 then check_single(thing_to_check.first)
    when 2 then check_tuple(thing_to_check)
    when 3 then check_triple(thing_to_check)
    else raise ArgumentError, "Invalid value: #{thing_to_check}"
    end
  end

  private

  # @rbs (untyped single) -> bool
  def check_single(single)
    return true if single.is_a?(Numeric)

    raise ArgumentError, "Invalid value: #{single_value}"
  end

  # @rbs (Array[untyped] tuple) -> bool
  def check_tuple(tuple)
    first, second = tuple
    return true if first.is_a?(Numeric) && second == :signed

    raise ArgumentError, "Invalid value: #{tuple}"
  end

  # @rbs (Array[untyped] triple) -> bool
  def check_triple(triple)
    first, second, third = triple
    return true if first.is_a?(Numeric) && second == :signed && third == :verified

    raise ArgumentError, "Invalid value: #{triple}"
  end
end

Given the simplicity of my example this seems fine but in a more realistic scenario where I might have dozens of branches all of which potentially lead to raise_invalid! doing this would be cumbersome and ultimately reduce the reusability of the code.

• Is there a better way to handle this type of scenario?
• Does RBS have a "this method always raises" type that steep would be happy with?
• Is there an alternative approach I'm not considering?

[Morriar]

Sorbet has T.noreturn for this: https://sorbet.org/docs/noreturn.