Ruby

Aren't accessors public by definition? If you want them to be private use attr.

Yes, they are public.

If I understood them correctly, they are the same as this in pure ruby code:

attr_accessor :foo def foo @foo end def foo=(i) @foo = i end 

I found that I personally only need attr_reader, attr_writer and attr_accessor.
I have not found a use case for attr alone yet.

I want to access my private fields also via methods instead of directly via instance variables so refactoring in future is easier. For example instead of finding in class all occurrences of @var = something and changing them into either "@var = something.strip" or extracting it into setter, I already use the private setter defined with attr_accessor everywhere. That way I only need to change the setter implementation in one place and don't need to look for code setting instance variable because there is non such, only calls for the accessor.

In general I support this request, but in this proposed use-case ...

attr_reader :foo private attr_writer :foo 

So one can use the symmetric foo and foo= in the class, but only the getter would be public.
This is also useful to evolve foo= (e.g., to invalidate some caches if set) and add extra logic in it, without having to change all places from @foo = to self.foo =.

foo= without @ or self. will assign a local variable. You'd have to change it to foo=(...) or send :foo=, ... anyway, no?

There's no use for private attr_reader, attr_writer, etc.

The intended usage is to ease future refactorings. If you always start with a method then later you can easily redefine just the method.

Initial code

class Something private attr_accessor :x, :y def something(a) self.x = a + y end end 

Code after refactoring:

class Something private attr_accessor :y private attr_reader :x def something(a) self.x = a + y end private def x=(new_value) @x_set_at = Time.now @x = new_value end 

Notice that nothing setting @x had to be refactored because @x variable was always changed via the self.x= setter.

So when the time comes and cache expiration or additional logic needs to be added, makes it easy to just redefine the setter or getter with additional logic.

That's why I always prefer to use private accessors instead of instance variables. They are more flexible.

This is implemented https://twitter.com/avdi/status/1380213296108867586. Let's close this ticket!

:)