Forum: Ruby-core Unifying the methods (const|class_variable|instance_variable)_(defined?|get|set)

43421679c356f438c69bf6947e62c4ec?d=identicon&s=25 Tsuyoshi S. (tsuyoshi_s)
on 2014-02-25 18:35
(Received via mailing list)
Issue #9565 has been updated by Tsuyoshi Sawada.


And I forgot to mention `local_variable_(defined?|get|set)` on
`Binding`. I propose that `Binding` should have these methods:

    token_defined? ==> instance_variable_defined?  (for arguments
prepended with @)
                   ==> local_variable_defined?     (for lowcase
arguments like "foo")
                   ==> Error                       (otherwise)

    token_get      ==> instance_variable_get       (for arguments
prepended with @)
                   ==> local_variable_get          (for lowcase
arguments like "foo")
                   ==> Error                       (otherwise)

    token_set      ==> instance_variable_set       (for arguments
prepended with @)
                   ==> local_variable_set          (for lowcase
arguments like "foo")
                   ==> Error                       (otherwise)


----------------------------------------
Feature #9565: Unifying the methods
(const|class_variable|instance_variable)_(defined?|get|set)
https://bugs.ruby-lang.org/issues/9565#change-45477

* Author: Tsuyoshi Sawada
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
An argument to methods of the form
`(const|class_variable|instance_variable)_(defined?|get|set)` already
describes if it is meant to be a constant, class variable, or instance
variable. For example, if `"Foo"` were to be used as an argument, a
meaningful usage may be using it with `const_get`, but not
`class_variable_get` or `instance_variable_get`. Whenever I use these
methods, I feel redundancy and extra burden of having to repeat the
information twice (once by method name and once by
capitalization/sigil).

I propose that if we use a common word (let's say `token`, but I am not
sure of this naming) in place of the words `const`, `class_variable`,
and `instance_variable`, and have methods to unify them and get rid of
the redundancy, then it would be easier for programmers. Particularly,
`Object` should have the following instance methods that are aliases of
the conventional methods:

    token_defined? ==> instance_variable_defined?
    token_get      ==> instance_variable_get
    token_set      ==> instance_variable_set

and `Module` should have the following instance methods that call
different methods or error depending on the first argument:

    token_defined? ==> const_defined?              (for capitalized
arguments like "Foo")
                   ==> class_variable_defined?     (for arguments
prepended with @@)
                   ==> instance_variable_defined?  (for arguments
prepended with @)
                   ==> Error                       (otherwise)

    token_get      ==> const_get                   (for capitalized
arguments like "Foo")
                   ==> class_variable_get          (for arguments
prepended with @@)
                   ==> instance_variable_get       (for arguments
prepended with @)
                   ==> Error                       (otherwise)

    token_set      ==> const_set                   (for capitalized
arguments like "Foo")
                   ==> class_variable_set          (for arguments
prepended with @@)
                   ==> instance_variable_set       (for arguments
prepended with @)
                   ==> Error                       (otherwise)

So when we use this, we do not have to think about the complicated
method name; we just need to provide the right argument:

    module A
      token_defined?("Foo") # => false
      token_set("Foo", 1)
      token_get("Foo")      # => 1

      token_defined?("@@foo") # => false
      token_set("@@foo", 2)
      token_get("@@foo")      # => 2

      token_defined?("@foo") # => false
      token_set("@foo", 3)
      token_get("@foo")      # => 3
    end
This topic is locked and can not be replied to.