Feature request: getters that return an immutable value

[stephane-archer]

I would be able to have getters that return an immutable value and create a compile error with the following code

class MyValue {
  int _value;

  MyValue(this._value);

  int get value => _value;

  void increment() {
    _value++;
  }
}

class MyClass {
  MyValue _myValue = MyValue(42);

  MyValue get myValue => _myValue;
}

void main() {
  final myObject = MyClass();

  print(myObject.myValue.value); // Access the value through the getter, prints: 42
  myObject.myValue.increment();  // Call the increment method
  print(myObject.myValue.value); // Access the modified value, prints: 43
}

Here is a possible syntax:

immutable MyValue get myValue => _myValue;

[eernstg]

Cf. #1518, quite similar.

[leafpetersen]

I don't understand what the request is, can you be more precise? The code you write there behaves precisely as you describe now. Where do you want a compile error? On the definition of the myValue getter? On the call to increment?

[stephane-archer]

Sorry for not being clear, I will try to re-explain.
In the example, MyClass has no control over who is modifying _myValue, it's his internal state and this totally breaks encapsulation in my opinion.
I did not create a setter in MyClass yet Everybody who has access to MyClass can modify _myValue by calling myObject.myValue.increment(); for example.
but I would like myObject.myValue to be "read-only", to be able to force that constraint so others (or my future self) to not be able to call myObject.myValue.increment(). If I was in C++ my getter would return a "const ref".
Today the only solution I found is to make the getter return a copy of MyValue so myObject.myValue.increment(); would have no effect on _myValue.
Does this make more sense?

[leafpetersen]

Why does this not do what you want:

abstract interface class ReadableMyValue {
  int get value;
}

class MyValue implements ReadableMyValue {
  int _value;

  MyValue(this._value);

  int get value => _value;

  void increment() {
    _value++;
  }
}

class MyClass {
  MyValue _myValue = MyValue(42);

  ReadableMyValue get myValue => _myValue;
}

void main() {
  final myObject = MyClass();

  print(myObject.myValue.value); // Access the value through the getter, prints: 42
  myObject.myValue.increment();  // Static error here
  print(myObject.myValue.value); // Access the modified value, prints: 43
}

[stephane-archer]

@leafpetersen This is doing exactly what I want. I didn’t know you could do that, thanks 🙏.
The only issue I see with this solution is that for every getter you have to create or modify an interface.
adding the const keyword on the return type in other languages is more convenient.

[leafpetersen]

const keyword on the return type in other languages is more convenient.

Yep. It's a big lift to figure out what the semantics of that should be. In the meantime, read only interfaces get you a fair distance.