Raising doesn't feel like a proper responsability of the exception.
On Sep 15, 2013 3:42 AM, "matz (Yukihiro Matsumoto)" <matz / ruby-lang.org>
wrote:

>
> 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/
>