[ruby-core:115934] [Ruby master Feature#20093] Syntax or keyword to reopen existing classs/modules, never to define new classs/modules

27 Dec 2023

      Issue #20093 has been updated by Edwing123 (Edwin Garcia).

If this feature has the purpose of making class/module extension explicit (meaning you can clearly see that a class/module is being open again to be extended), then I agree with it.

By the way, I think the keyword `open` is more suitable:

```ruby
class Foo
end

# Yay! Explicitly opening
# a class for extension.
open class Foo
 def bar()
 end
end
```

I like that we're being explicit, so with this when reading code, we can answer that the class/module is being open for extension and that its "canonical" definition is somewhere else.

Regarding backward compatibility:

- Should the `open` keyword be optional in order for existing code to keep working?

If that's the case, then existing  code that doesn't use `open` won't benefit from this:
...
Raise errors if the specified class/module is not defined.
So, only code using `open` will opt into checking if the class/module being open is already defined.

I believe this is fine, and this proposal opens the door to adding a feature that will make reading Ruby code more clearly. Eventually gems and applications can adopt the new keyword!

----------------------------------------
Feature #20093: Syntax or keyword to reopen existing classs/modules, never to define new classs/modules
https://bugs.ruby-lang.org/issues/20093#change-105885

* Author: tagomoris (Satoshi Tagomori)
* Status: Open
* Priority: Normal
----------------------------------------
`class A` and `module B` will reopen existing class A or module B to add/re-define methods if A/B exists. Otherwise, these will define the new class/module A/B.
But, in my opinion, the code of `class A` for patching existing classes doesn't work expectedly when `A` is not defined beforehand. It expects other codes to define `A` before being called.

For example:

```ruby
# string_exclude.rb
class String
  def exclude?(string)
    !include?(string)
  end
end
```

This code expects that there is the `String` class, and it has the `include?` method. This code doesn't work if the file is loaded in the way below:

```ruby
load('string_exclude.rb', true)
```

This code doesn't raise errors and will define an almost empty class (only with a method `exclude?` to raise NameError). It should be unexpected for every user.

So, I want to propose a new syntax to reopen the existing class/module or raise errors if the specified class/module is not defined.

```ruby
class extension String
  def exclude?(string)
    !include?(string)
  end
end # adds #exclude? to String class

class extension Stroooong
  def exclude?(string)
    !include?(string)
  end
end # will raise NameError (or something else)
```

Some additional things:

* `class extension String` (and `module extension String`)  causes a compile error (SyntaxError) on Ruby 3.3. So we have space to add a keyword between class/module and the class/module name.
* I don't have a strong opinion about the keyword name `extension`. An alternative idea is `reopen`.

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