From: "sawa (Tsuyoshi Sawada)" <sawadatsuyoshi@...>
Date: 2013-09-15T14:57:24+09:00
Subject: [ruby-core:57206] [ruby-trunk - Feature #8912] Exception#raise


Issue #8912 has been updated by sawa (Tsuyoshi Sawada).


> matz, thank you for the comment.

I think that raising an error is a peculiar property of an instance of `Exception`. Every time we `raise`, we raise one and only one exception, and nothing else. No other type of object can be raised. From object oriented point of view, this tells us that the method should belong to the `Exception` class, not `Kernel`.

Furthermore, it is rare that we want to create an instance of an Exception without raising it. If `Exception#new` exists, there is even more reason to have `Exception#raise`. The latter is more usable than the former.

In fact, method "raise" should be considered as a constructor with a side effect (of raising the exception). Various constructors are defined as class methods, and I don't understand why that is not the case for exceptions.

From a practical point of view, I feel repeating the extra pairs of parentheses cumbersome.

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

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/