[ruby-core:113749] [Ruby master Feature#19708] Support `attr_reader :foo?`

Issue #19708 has been updated by rubyFeedback (robert heiler).


Personally I agree with the proposal, largely because I love
methods that end with a trailing '?' - I think that was a good
language decision choice matz made to indicate query-like methods
via ?.

Such as:

    if game_over?
      notify_the_user_that_the_game_is_over
    end

I kind of have stopped using attr* methods though, in part because
I could not use them for trailing '?', but in part also because I
seem to become lazier whenever I use attr methods. Additionally some methods
need to do some clean-up and sanitization steps in certain classes, and
the attr-methods only really are super-simple, not allowing for extra
actions here - e. g. just to be used as setters and getters.

I do seem to remember that there was a reason given as to why no trailing
'?' method exists for the attr-family of methods. I think matz mentioned
this once on the bugtracker, but I forgot the explanation.

> You can workaround this by using attr_reader to create the
> optimized method, alias_method to give it the nice active?
> name, and then remove_method to delete the original non-?
> name:

There are many work arounds. I simply use the "def" variant. :P

    def age?
      @age
    end; alias age age?

(Although for larger classes, I shifted towards using a Hash
that keeps track of all instance variables instead. I found that
once you have like ~20 different instance variables, a Hash seems
easier to understand than individual instance variables.)

Note that I think your proposal has not been clear in regards to
what attr_reader would do.

Are these two separate methods or not? Consider this:

    attr_reader :foobar
    attr_reader :foobar?

Both would query over @foobar, right? But are these the same
methods or different? e. g. when someone undefines/removes
them, is the other one removed or not? That should also be clarified
in the proposal IMO, just to make it instantly clear to the dev
team what is meant exactly.

----------------------------------------
Feature #19708: Support `attr_reader :foo?`
https://bugs.ruby-lang.org/issues/19708#change-103396

* Author: AMomchilov (Alexander Momchilov)
* Status: Open
* Priority: Normal
----------------------------------------
Creating reader methods with `attr_reader` is preferable over defining them by hand, not only because it's more convenient, but also because it hits a fast path in MRI (see `VM_METHOD_TYPE_IVAR`).

Since local and instance variables can't end with `?`, you can't use `attr_reader` to define predicate-style methods for boolean values, like:

```ruby
class Person
  attr_reader :name, :age, :active? # invalid attribute name `active?' (NameError)
  
  def initialize
    @name = "Bob"
    @age = 30
    @active = true
  end
end
```

It would be nice if `attr_reader` (and friends) could behave like:

```ruby
def active? = @active
```

(`attr_writer` and `attr_accessor` couldn't do the same, since `def active?=(new_value)` isn't valid, so they'd probably stick with `def active=(new_value)`)



-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/