Generic type mismatch with Readonly<T> #18094

Activity

1. ahejlsberg commented on Aug 28, 2017

   

   Anders Hejlsberg (ahejlsberg)

   on Aug 28, 2017

   Member

   More actions

   This is working as intended and is an effect of #16368. The type checker is pointing out that it is not safe to treat the doIt(data: Readonly<II2>) method in MySubClass as the more general doIt(data: Readonly<T>) in MyClass<T>. Effectively, you can't treat a method that expects the specific type II2 as a method that accepts any type that derives from MyInterface.
2. Anders Hejlsberg (ahejlsberg)

   added

   Working as IntendedThe behavior described is the intended behavior; this is not a bugThe behavior described is the intended behavior; this is not a bug

   on Aug 28, 2017
3. dpogue commented on Aug 28, 2017

   

   Darryl Pogue (dpogue)

   on Aug 28, 2017

   Author

   More actions

   This feels like it limits generics to the point where they're hardly useful anymore...

   What we're trying to model is a "Model" class that wraps some data handled by a JSON API:

   interface IModelData {
     href : string; // All models have an href
   }
   
   class ModelBase<DataType extends IModelData> {
     persist(data : Readonly<DataType>) {
       return callToServer(data['href'], data);
     }
   }
   
   
   interface IUserData extends IModelData {
     username : string;
   }
   
   class User extends ModelBase<IUserData> {}

   What is the correct way to model this in TypeScript that allows proper typechecking?
4. ahejlsberg commented on Aug 29, 2017

   

   Anders Hejlsberg (ahejlsberg)

   on Aug 29, 2017

   Member

   More actions

   One way to model it is to have a non-generic base class:

   interface IModelData {
     href : string; // All models have an href
   }
   
   abstract class ModelBase {
     abstract persist(data: IModelData): void;
   }
   
   class GenericBase<DataType extends IModelData> extends ModelBase {
     persist(data : Readonly<DataType>) {
       return callToServer(data['href'], data);
     }
   }
   
   interface IUserData extends IModelData {
     username : string;
   }
   
   class User extends GenericBase<IUserData> {}
   
   function fn(arg: typeof ModelBase) {};
   
   fn(User);

   Another way is to not use typeof ModelBase but instead write out the actual factory type:

   interface IModelData {
     href : string; // All models have an href
   }
   
   class ModelBase<DataType extends IModelData> {
     persist(data : Readonly<DataType>) {
       return callToServer(data['href'], data);
     }
   }
   
   interface IUserData extends IModelData {
     username : string;
   }
   
   class User extends ModelBase<IUserData> {}
   
   function fn(arg: new() => ModelBase<IModelData>) {}
   
   fn(User);

   With either approach you're ensuring that the arg parameter of fn is a contract that is satisfied by every subclass constructor function.
5. mhegazy commented on Sep 12, 2017

   

   Mohamed Hegazy (mhegazy)

   on Sep 12, 2017

   Contributor

   More actions

   Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.
6. Mohamed Hegazy (mhegazy)

   closed this as completedon Sep 12, 2017
7. microsoft

   locked and limited conversation to collaborators on Jun 14, 2018