[ruby-core:57208] [ruby-trunk - Feature #8912] Exception.raise

Issue #8912 has been updated by matz (Yukihiro Matsumoto).


As Nobu pointed out, we need to use the proper terms:

 * Exception.raise instead of Exception#raise
 * Exception.new instead of Exception#new

We have to distinguish class methods and instance methods.

Then I think we need a way to separate allocating and raising.
By providing Exception.raise (and discouraging Kernel#raise), there's no sufficient way to raise pre-allocated exceptions.
Kernel raise takes either exception class or exception instance.

If we really need to emphasize OO way in raising exception as you claim, I'd rather add Exception#raise, i.e.

  MyException.new(:foo,:bar).raise

But in reality, I prefer traditional

  raise MyException.new(:foo,:bar)

because 'raise' is a core operation, that often is implemented by the reserved keyword in other languages,
and maybe we will replace it by (somewhat-soft) keyword in the future.

Matz.


----------------------------------------
Feature #8912: Exception.raise
https://bugs.ruby-lang.org/issues/8912#change-41820

Author: sawa (Tsuyoshi Sawada)
Status: Feedback
Priority: Normal
Assignee: 
Category: 
Target version: 


=begin
When we have a custom exception class with a custom (({initialize})) method whose arity is not (({1})):

    class MyException < StandardError
      def initialize x, y
        super("Something went wrong with #{x.inspect} because #{y}, blah blah")
      end
    end

in order to raise it, we have to create a new instance of it explicitly using (({new})), and embed that under (({Kernel#raise})).

    raise(MyException.new(:foo, :bar))

This is inconvenient, and does not look object oriented. I propose that there should be (({Exception#raise})), which is public, so that we can do:

    MyException.raise(:foo, :bar)

A Ruby implementation may be like this:

    class Exception
      def self.raise *args; Kernel.send(:raise, *args) end
    end

This will disallow us from calling the private method (({Kernel#raise})) (without an explicit receiver) within the context of an (({Exception})) class unless we use (({send})), but I think such use case is rare, and that should not be a problem.
=end



-- 
http://bugs.ruby-lang.org/