[feature] class properties that are "readonly in public, writable in private" or other permutations

Search Terms

typescript readonly on the outside writable on the inside

https://stackoverflow.com/questions/46634876/how-can-i-change-a-readonly-property-in-typescript

Suggestion

Some sort of syntax to describe readonly on the outside, writeable on the inside for a given property, so we can avoid making a getter just for this purpose (or using any of the convoluted options linked in that StackOverflow post).

Use Cases

To make this pattern easier to express.

Examples

instead of having to write

class Foo {
  private _foo = 123
  get foo() {
    return this._foo
  }

  changeIt() {
    this._foo = 456
  }
}

const f = new Foo
f.foo = 345 // ERROR

we would be able to write something shorter like

class Foo {
  publicread foo = 123

  changeIt() {
    this.foo = 456
  }
}

const f = new Foo
f.foo = 345 // ERROR

Checklist

My suggestion meets these guidelines:

This wouldn't be a breaking change in existing TypeScript/JavaScript code
This wouldn't change the runtime behavior of existing JavaScript code
This could be implemented without emitting different JS based on the types of the expressions
This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
This feature would agree with the rest of TypeScript's Design Goals.

Previously at #2845 but we should revisit after so long

Just a note, but #2845 is similar but different. This one is not about making a getter/setter, but about making only a property, and being able to specify that the property be readonly on the outside of the class, and writable only inside the class (and subclasses too, depending on the keyword used)

Taking the idea a little further:

class Foo {
  // readonly in public code or subclasses, writable in this class only
  publicread privatewrite foo = 123

  // readonly in public code, writable in this class or subclasses
  publicread protectedwrite bar = 123

  // not visible in public code, readonly in subclasses, writable in this class only
  protectedread privatewrite baz = 123
}

and otherwise public is equivalent to publicread publicwrite, protected is equivalent to protectedread protectedwrite, and private is equivalent to privateread privatewrite, where the write specifiers can not be less strict than the read specifiers (or can they?).

Joe Pea (@trusktr)

I'd love this feature in Typescript. It would allow me to simplify so many of my classes, especially in libraries and packages that expose a public API.

I'm not a huge fan of the publicread privatewrite syntax proposed by Joe Pea (@trusktr) as those keywords feel a little 'forced' to me. How about using the existing readonly keyword and allowing multiple access modifiers in increasing order of specificity (public > protected > private). Access is then resolved from right to left, with the first matching access modifier defining the access level and readonly status:

// Seen as `private foo` by class members
// Seen as `public readonly foo` by other code
public readonly private foo : Foo;

// Seen as `private foo` by class members
// Seen as `protected readonly foo` by subclass members
// Not accessible by other code
protected readonly private foo : Foo;

// Seen as `protected foo` by class and subclass members
// Seen as `public readonly foo` by other code
public readonly protected foo : Foo;

// Would technically be valid as well, though not very useful
// Seen as `private readonly foo` by class members
// Seen as `protected foo` by subclass members
// Seen as `public readonly foo` by other code
public readonly protected private readonly foo : Foo;

// Throws an error on compile, since the `private` modifier is more specific than `public`
private public readonly foo;

The upside of this would be that we don't introduce new keywords, and the syntax is flexible enough in case other modifiers like readonly are added.

A downside would be that function signatures like these are a little harder to parse visually when reading the code. But then the same could be said for everything that adds more keywords.

A question here would be how to handle the 'no access modifier = public' rule that Typescript uses. Should the public modifier be required for signatures with multiple access modifiers, or would the following also be valid?

readonly private foo : Foo;

I'd argue that this could get confusing (was this intentional or did someone mix up the order of keywords?) so I think an explicit public modifier should be required.

Note: this is written by someone who has no knowledge of the Typescript compiler or language design in general. So I don't know how easy/difficult/impossible this would be to implement. I'm curious to get some feedback on the syntax and on why this is or isn't a good idea.

Joe Pea (@trusktr)

Just encountered a use case for this today when writing out a value ref class.

class Ref <T> {
  readonly value: T;
  constructor (value: T) {
    this.value = value;
  }
  set (value: T) {
    this.value = value; // errors unless I override the type of `this`
    return value;
  }
  // ...
}

Overriding the type of this, can get annoying fast if you have lots of methods that need write access.

There are other ways around it like storing the value in a private field then creating a getter, but that adds a performance penalty.

Joe Pea (@trusktr) It might be best to default reads to always be public.

// Seen as `private foo` by class members
// Seen as `public readonly foo` by other code
privatewrite foo: string

This goes along with how typescript works now, fields are by default public and you narrow their scope using private or protected. My guess is it would also be easier to accommodate most cases without the need to explicitly define both read and write.

Also here's how I am getting around this issue right now. It's a bit cumbersome, but maybe it will help out others who desire this feature.

type Writeable <T> = {
  -readonly [P in keyof T]: T[P];
};

type WritebaleRef <T> = Writeable<Ref<T>>;

class Ref <T> {
  readonly value: T;
  constructor (value: T) {
    this.value = value;
  }
  set (this: WritebaleRef<T>, value: T) {
    this.value = value; // no error because `this` type is changed to WritebaleRef<T>
    return value;
  }
  // ...
}

This is one of the features I miss so much in TypeScript.

I don't really like the publicread privatewrite notation. Is there an other language that uses that notation?

Here are a few suggestions:

// Option 1: C# style
public name: string { get; private set; }

// Option 2: Swift style
private(set) name: string

// Option 3: Swift struct-style
public readonly name: string

mutating changeName(name: string) {
  this.name = name
}

// Option 4: New keyword
public frozen name1: string
public readonly name2: string

My choice would be the Swift style (option 1) or C# style (option 2). Option 3 is for if we can't change the property definition.

I also like the C# syntax but I think it's too far from the way getters and setters are defined in JS/TS so it would look out of place. Swift syntax looks nice though.

Wouter Buckens (@woubuc)

Neat to know how other languages do this.

Wouter Buckens (@woubuc) Your idea is great if we need to prevent from adding new keywords.

With the new keywords I suggested we can do things like

publicwrite protectedread privatewrite foo = 123

which makes foo writable only in public and private code, but not in subclasses (it could be a valid use case, f.e. "I want this class to handle user input for foo, but I don't want subclasses to interfere with user input of foo, while the subclasses can still extend functionality in other areas").

Wouter Buckens (@woubuc) How would we specify the same thing with the space-separated existing keywords? Would it be

public protected readonly private foo = 123

?

Also with the new keywords, order wouldn't matter (or at least, the intention is clear regardless of order):

privatewrite protectedread publicwrite foo = 123

Here's my attempt with the existing keywords:

private protected readonly public foo = 123

But with the new keywords, what would happen if someone tries to use the existing keywords?:

privatewrite protectedread protected publicwrite  foo = 123

Perhaps they'd need to be mutually exclusive, so we can either use only the existing keywords, or only the new ones, but not both.

The Readonly<T> generic type (or an interface) will do the "public readonly, private writable" pattern.

interface IFoo {
  readonly foo: number
}
class Foo implements IFoo {
  foo = 123

  changeIt() {
    this.foo = 456
  }
}

const f: Readonly<Foo> = new Foo
const g: IFoo = new Foo

whzx5byb

whzx5byb I appreciate your example, but it is not a solution to the problem.

the compiler would still allow me to create an instance of Foo and then set the foo variable
this forces the developer to use interfaces instead of classes
this becomes impractical in more complex constructs like inheritance

I'm not sure overly precise granularity is useful if it makes us write crazy things to define properties?

I think something simple like the following would do the trick:

class Foo {
  /**
   * foo can be read from public, protected and private contexts,
   * writable only within the class and its subclasses.
   */
  public protected foo: number;
}

class Bar {
  /**
   * bar can be read from public, protected and private contexts,
   * writable only within the class.
   */
  public private bar: number;
}

class Buzz {
  /**
   * buzz can be read from protected and private contexts,
   * writable only within the class.
   */
  protected private buzz: number;
}

Adding "larger" modifiers would only expand readability, and writabiIity would be kept to the most restricted modifier. ~~We can finally add the readonly keyword in this word soup to close this last scope and never be able able to write.~~

edit: Actually you would never need to mix the readonly keyword with more than one access modifier.

I don't really see a case where someone would want it the other way around, like "public read/write and protected readonly".

"public read/write and protected readonly".

@marechal-p The example I showed above was "public read/write, protected readonly, private read/write". In that concept, this allows the public (end users) to pass data in, and only allows the private scope to have full control (subclasses aren't afforded this).

With your idea (which I do like as a subset and feel that it would already be a lot better than what we currently have), how could we implement similar? Seems impossible.

I think being able to distinguish public input from protected input (in the private scope) could be useful. But I would totally settle with your idea over the current.

I agree that the compound words are ugly but TS is based on JS / ES, not Swift, and has no other cases where a modifier uses function-like syntax similar to what you've linked. I believe that there are combinations of existing reserved words, in an order that is currently a syntax-error (and thus shouldn't be a breaking change!), which would suffice to implement this feature.

Robbie Speed (@robbiespeed)

After going through the protectedwrite proposal (which already satisfies my needs) I think another possible future addition would be a privatewrite modifier as suggested by Robbie Speed (@robbiespeed).

These write modifiers play well with the standard access modifiers public, private, and protected and from my point of view are very easy to reason about.

class Order {
  // Can write from this class only, read from anywhere
  privatewrite price: number;

  // Same as above, but explicit public access
  public privatewrite price: number;

  // Accessable from this class and subclasses, writable only from this class
  protected privatewrite price: number;

  // Compiler/linter warning because privatewrite has no effect
  private privatewrite price: number;

  // Compiler error because readonly conflicts with privatewrite
  readonly privatewrite price: number;
}

Feel like this suggestion is blocked because of we haven't found a syntax people love, so throwing another option into the ring:

Overloading

Undo the requirement that members must have identical modifiers, and embrace the modifiers being different:

class Dog {
    public readonly name: string;
    private name: string = "abc";
}

class Cat {
   protected readonly _age: number;
   private _age: number = 123;
}

The separate modifier overloads are collapsed together and tested against based on where the access is happening. Only one override can set a default value. Remove the duplicate identifier warning, but add a warning if overloads are not adjacent (same as method overloads).

I like this idea because it reinforces the notion that access modifiers, like function parameter types, are a type-space construct. I'm not clear on your Cat example though - what does it mean to have two protected declarations?

Feel like this suggestion is blocked because of we haven't found a syntax people love, so throwing another option into the ring:

Overloading

Undo the requirement that members must have identical modifiers, and embrace the modifiers being different:
class Dog {
    public readonly name: string;
    private name: string = "abc";
}

class Cat {
   protected readonly _age: number;
   protected _age: number = 123;
}
The separate modifier overloads are collapsed together and tested against based on where the access is happening. Only one override can set a default value. Remove the duplicate identifier warning, but add a warning if overloads are not adjacent (same as method overloads).

That would be like my suggestion at #43553 which also has the benefit of supporting stricter types for broader access scopes.

I like this idea because it reinforces the notion that access modifiers, like function parameter types, are a type-space construct. I'm not clear on your Cat example though - what does it mean to have two protected declarations?

Similar thoughts on this one. Regarding the Cat example, it needs to be decided, if it has any relevance at all, or if it should rather be an error reported at compile time. The behavior is hard to predict (can the subclass now modify the value or not?), thus, I would rather suggest a compile-time error.

Suggestion for compile-time error: I think, as a rule of thumb, the readonly part must always have higher visibility than the writable part. Otherwise, a compile-error should be reported.

I'm not clear on your Cat example though - what does it mean to have two protected declarations?

Thanks! That was a typo. Second one should've been private. I've updated the code.

I think the best way to implement this is a possibility to add different types for each access modifiers.
This will be useful for mutable properties like arrays, map and sets.

//foo is readonly in public, but can be changed by this and derived classes.
public readonly foo : number;
protected foo : number;
private foo : number;

//other classes can't add items to `data`, but current class can.
public readonly data: ReadonlyMap<string, number>;
private data : Map<string, number>;

public readonly foo : number;
protected foo : number;
private foo : number;

If property has an initializer, where should I pass it in your example?

foo: number = 123;

public readonly foo : number;
protected foo : number;
private foo : number;
If property has an initializer, where should I pass it in your example?
foo: number = 123;

I think it shouldn't be matter, just use one of them.

Hi. There is a tc39/proposal-grouped-and-auto-accessors that suggested syntax for read-only field, but using same syntax as ECMAScript private fields. This will be compatible with ECMAScript decorators currently being worked on for TS 5.0 #48885

// code from proposal
class C {
  accessor a = 1;                   // same as `accessor a { get; set; } = 1;`
  accessor b { } = 1;               // same as `accessor b { get; set; } = 1;`
  accessor c { get; set; } = 1;     // same as `accessor c = 1;`
  accessor d { get; } = 1;          // getter but no setter
  accessor e { set; } = 1;          // setter but no getter (use case: decorators)
  accessor f { get; #set; };        // getter with private setter `#f`;
  accessor g { #set; } = 1;         // private setter but no getter (use case: decorators)
  accessor #h = 1;                  // same as `accessor #h { get; set; } = 1;`
  accessor #i { } = 1;              // same as `accessor #i { get; set; } = 1;`
  accessor #j { get; set; } = 1;    // same as `accessor #j = 1;`
  accessor #k { get; } = 1;         // getter but no setter
  accessor #l { set; } = 1;         // setter but no getter (use case: decorators)
}

So, I suggest just add access modifiers into brackets like this:

accessor a { get; protected set; };
accessor b { get; private set; };
accessor c { 
  get() { ... } 
  protected set(value) { ... }
};

That looks great as far as accessor properties are concerned but this thread is largely concerned with data properties.

Sviatoslav Zaytsev (@sviat9440)

Sviatoslav Zaytsev (@sviat9440) There are two options, it could work exactly as overloads on functions do right now, so you'd declare the implementation last (and independently) like this:

public readonly foo: ReadonlyMap<string, string>;
private foo: Map<string, string>;
foo = new Map<string, string>();

Second option is to combine an overload signature and an implementation. This would be slightly different to how overload functions work now (but slightly more convenient), because if an overload signature exists the base signature of the function is not used outside the implementation.

public readonly foo: ReadonlyMap<string, string>;
private foo: Map<string, string> = new Map();

The implementation should be last for style reasons, but it shouldn't be enforced (otherwise ESLint would probably generate an no-redeclare error but TS itself shouldn't care).

All signatures should be adjacent or TS generates a should be adjacent error.

Signatures must be compatible with the implementation or TS generates a must be compatible error.

Having a second implementation would make TS generate a no same property error as it does right now.

Dave Houlbrooke (@dhoulb)

Dave Houlbrooke (@dhoulb) go idea

I think force add declare keyword would be more safe:

declare protected foo :number;
private foo :number = 1;

At least forbid to write assignment not at last to avoid:

private foo :number = 1;
protected readonly foo :number;

being transformed by old type eraser util to:

foo = 1;
foo;

which cause runtime 1 disappear bug.

Feel like this suggestion is blocked because of we haven't found a syntax people love, so throwing another option into the ring:

Overloading

Undo the requirement that members must have identical modifiers, and embrace the modifiers being different:
class Dog {
    public readonly name: string;
    private name: string = "abc";
}

class Cat {
   protected readonly _age: number;
   private _age: number = 123;
}
The separate modifier overloads are collapsed together and tested against based on where the access is happening. Only one override can set a default value. Remove the duplicate identifier warning, but add a warning if overloads are not adjacent (same as method overloads).

I like this as it's common to expose a sub-class publicly.

class Example {
    public readonly data: ReadonlyMap<string, string>
    private readonly data: Map<string, string>
    
    // ...
}

Also lets us hide function parameters:

class Example {
    public readonly doStuff()
    private readonly doStuff(hiddenOption)
    doStuff(hiddenOption) {
        // do stuff
    }
}

This also has the benefit of not introducing new keywords.

Navigation Menu

Repository navigation

[feature] class properties that are "readonly in public, writable in private" or other permutations #37487

Search Terms

Suggestion

Use Cases

Examples

Checklist

41 remaining items

Overloading

Overloading

Overloading

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

[feature] class properties that are "readonly in public, writable in private" or other permutations #37487

Description

Search Terms

Suggestion

Use Cases

Examples

Checklist

Activity

RyanCavanaugh commented on Mar 20, 2020

trusktr commented on Mar 22, 2020

woubuc commented on May 20, 2020

robbiespeed commented on Jun 11, 2020

yvbeek commented on Jun 23, 2020

woubuc commented on Jun 24, 2020

trusktr commented on Aug 4, 2020

whzx5byb commented on Aug 17, 2020

yvbeek commented on Aug 21, 2020

paul-marechal commented on Sep 21, 2020

trusktr commented on Nov 3, 2020

41 remaining items

thw0rted commented on Mar 22, 2022

ifeltsweet commented on Jul 6, 2022

dhoulb commented on Sep 2, 2022

Overloading

thw0rted commented on Sep 2, 2022

Jet132 commented on Sep 3, 2022

Overloading

mmichaelis commented on Sep 3, 2022

dhoulb commented on Sep 3, 2022

khokm commented on Oct 17, 2022

sviat9440 commented on Oct 18, 2022

khokm commented on Oct 18, 2022

zkulbeda commented on Nov 3, 2022

snarfblam commented on Nov 3, 2022

dhoulb commented on Nov 21, 2022

LongTengDao commented on Dec 9, 2022

TheCymaera commented on Apr 9, 2023

Overloading

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions