From: drenmi@... Date: 2020-03-06T06:50:58+00:00 Subject: [ruby-core:97379] [Ruby master Feature#16615] Group style access scope for macros Issue #16615 has been updated by ted (Ted Johansson). shevegen (Robert A. Heiler) wrote in #note-1: > Two comments from me in regards to the proposal: > > 1) Is there a defining difference towards e. g. the attr* family? Perhaps I missed this > in the proposal, but it should be remembered, even more so as this may become a question > to newcomers for ruby - see the old questio about "Symbol versus String" and strange > add-ons such as HashWithIndifferentAccess. The `attr_*` family of methods currently enjoys special treatment here, as they are the only methods which define instance methods that will obey this style of visibility scope. > 2) I believe the name "macro" is an awkward name. I am not sure that name should be added, > but even more importantly the relatedness to 1) should be considered. I changed the name to a meta-syntactic variable, since it's irrelevant to the proposal itself. > (The public versus private distinction in ruby is not a strong one, due to ruby's dynamic > nature and philosophy. [...] I think it then comes down a lot to the personal preferences > of a given ruby user more than anything else.). I think you might be projecting your personal opinion onto "Ruby in general". I can't think of any library which doesn't make extensive use of encapsulation. (For example, Rails has 1,073 uses of `private`.) Not saying you have todo it in your projects, but it is a thing, and in my experience working with large code bases, it's also a Good Thing���. :-) ---------------------------------------- Feature #16615: Group style access scope for macros https://bugs.ruby-lang.org/issues/16615#change-84505 * Author: ted (Ted Johansson) * Status: Open * Priority: Normal ---------------------------------------- Given a method `.bar`, which defines an instance method `#bar` on a class, and returns the defined method's name as a symbol (`:baz`). ``` class Foo private # On evaluation defines a method and returns its name. # In current Ruby, that method will be public. The suggested # behaviour is to make it private, since the class method # which defines the instance method is in the private scope. # bar :baz end ``` it would be neat if the dynamically defined instance method respected the scope in which its definition originated. (In this particular case `private`.) Essentially the request is to extend the special powers of `attr_*` (being able to define methods that honour visibility scopes) to any method. Note: I am aware that inline access scopes already work for dynamically defined methods, as they merely accept a symbol as an argument. Edit: Changed `macro` to `bar` so people don't get hung up on the name of the method (which has no importance to the proposal.) -- https://bugs.ruby-lang.org/ Unsubscribe: