Add private set property modifier

[tilucasoli]

Introduce a property-level modifier similar to Swift’s private(set) functionality. This would allow a class to expose a property for reading externally while restricting write access.

Motivation

In Swift, a common pattern is to declare properties as public private(set), which makes them publicly readable but only privately (or internally) writable. However, Dart does not have a similar feature, so we have to create a private variable along with a getter to achieve the same functionality.

Swift Example:

public class SomeClass {
    public private(set) var count: Int = 0
    
    public func increment() {
        count += 1
    }
}

Dart Example:

class SomeClass {
  int _count = 0;
  
  int get count => _count;
  
  void increment() {
    _count++;
  }
}

Proposed Solution

_set

class SomeClass {
  // Publicly readable, privately writable
   _set int count = 0;

  void increment() {
    count += 1; // Allowed
  }
}

// Outside SomeClass
void main() {
  final obj = SomeClass();
  print(obj.count); // Allowed
  // obj.count = 5; // Not allowed: write access is private
}

@nonVisibleSet

Alternatively, a annotation-based could be another option.

class SomeClass {
  @nonVisibleSet
  int count = 0; // read from anywhere, write only from within this class
}

[lrhn]

I've suggested something like that before. Can't find it right now.
The idea was to have bundled "property" declarations where you could declare implicit getter and/or setter for a variable independently, and also choose their names.

Strawman syntax:

int _value {
  get value;
  set;
};

This block states that there is a getter named value and a setter named _value for a variable which is itself named _value.(The name of a variable can only be used in one place: Constructor initialization, as this._value or _value = expr. Any other reference to the variable is a reference to a getter or setter, but initialization refers to the underlying storage location itself.)

By allowing you to specify an alternative name for a getter or setter, you can end up with default getters and setters for a variable with different names, including one being private.

Another way to write the same thing might be

int value { set _value; };

because you can't omit a getter, so omitting it is equivalent to get;, which is short for get value;.
You only need to say whether there is a setter, and then you can give it a non-standard name.

(Annotations are not an option. An annotation cannot change language behavior, so @nonVisibleSet int count = 0; would be visible to the language. The analyzer may warn if you access it, but you can // ignore: that if you want to.)

[tilucasoli]

I like this sintax, for me it works

int a { set _a; }

What if I set an initial value for 'a'?

It would be something like this?

int a = 1 { set _a; }

For each verb in {get, set}, there are 4 possibilities:

• omit it
• write only verb
• write verb followed by a _name (with the underscore)
• write verb followed by a name (with no underscore)

Each of those has to be translated into the human language while reading the program (16 combinations in total).
That's not all. The declared name also comes in 2 colors: int _a and int a, so this has to be taken into account while figuring out the overall meaning.
It's complicated 😄

Please consider a different syntax (C#-inspired)

int _a via a { get; set; } // "via" or something to the same effect

which is a shorthand for

int _a;
int get a => _a;
set a(int value) => _a = value;

In C#, there's also an "init" setter to be used in the constructor; in dart, we can use its variant to provide a default value for the constructor parameter, e.g.

final int x = 0; // looks bad. What does it mean? We want to set it in a constructor through an optional parameter.  
final int x { init = 0; } // better, the default for an optional parameter is 0

[lrhn]

This syntax is C++ inspired.
Personally I don't like that via (not even named as), and think

int _a {get a; set a;}

reads better. And it allowed the getter and setter to have different names if you want it.

It does mean you have to say the name twice, but only if both are different from the storage name, and unlike C# you don't need to have a private storage to support public getters and setters, so you can always make one of them the same name as the field. The above could just be int a {get; set!}, there is no easy to tell the difference.

int _a {get a;}

doesn't tell you there's no setter called "a". There can be an old-style setter set a(int value) => _a = value;
In contrast, the expression int _a as a {get;} kind of "reserves" a, so you can't write a separate setter called a.
Compare with your syntax for public name: if you declare int a {get;} you cannot define a separate setter for a (the compiler will complain about the duplicate name). The syntax int _a as a {get';} is trying to achieve the same for a private _a.

One interesting possibility is that if something is declared with the syntax int a {get;} then it becomes a final variable, and in addition to this - a "stable" one, because the compiler will disallow creating a setter in subclasses. (We can interpret the syntax {get;} as saying there's no setter, so neither the class nor the subclass would be allowed to create one). @lrhn, may it work?
(the main argument here is that get has no body, so it can't return different results on different invocations. If the subclass wants to override, it would be required to use the same syntax int a {get;).

[nate-thegrate]

if something is declared with the syntax int a {get;} then it becomes a final variable, and in addition to this - a "stable" one, because the compiler will disallow creating a setter in subclasses.

That does sound really cool. Considering the overhead of implementation on the language side along with developers needing to wrap their head around another way to do things, IMO the syntax ought to let you do something you couldn't before.

[lrhn]

Over thing you couldn't before would be overriding the default implementation.
This feels like augmentations today, but I wanted this long before augmentations were a thing.

int length {
  get;
  set(v){
    var oldLength = length;
    if (v != oldLength) {
       length = v;
       _lengthChange.add((oldLength, v));
     }
  }
}

You can declare getters and setters directly with the variable. Inside those, the unqualified variable name refers directly to the field storage, so length = ... doesn't recursively call the setter.

This idea stated as a syntax for just declaring getters and setters together, instead of as two separate declarations that hve to repeat the type and name.
It can also be applied to variable declarations, allowing you to replace the implicit getter and/or setter in-place, rather than having to have a storage æ separate storage variable just to have a custom setter. (Does need some way to distinguish pure getter/setter declarations from variable declarations.)

[tilucasoli]

@lrhn what if add a custom logic for get? is it the expected sintax?

int length {
  get() { 
    doSomething();
    return length;
  }
}

[lrhn]

Yes, probably without the parentheses.
Like a getter with implicit name and return type.

So you can do

int counter {
  get => ++counter;
} = 0;

Or something. Still need some details, since this variable is apparently mutable, but didn't have any setter.

That only works if you are the one declaring the variable. If you can use the same syntax for overriding getters and setters, there needs to be a distinction between introducing a new storage location or not.

[tilucasoli]

@lrhn What are the next steps to make this feature available? How can I help?

[lrhn]

The most important step is to give reasons why this feature is more important than other feature that the Dart language and implementation teams can spend their resources on.

It's a brevity feature. It cannot do anything new that you can't do today with more declarations.

So it had to be something that happens often enough that improving the floor for programmers is worth the cost.