Activity

1. JonathanDCohen commented on Apr 7, 2021

   

   Jonathan Cohen (JonathanDCohen)

   on Apr 7, 2021

   Last edited by JonathanDCohen

   Author

   More actions

   I've discovered that

   function f(request: {params: {[param: string]: unknown;}}) {
       let x = request.params.x;
       try {
           x = validate(x);
           takesString(x)
       } catch (e) {}

   also fails to compile. So maybe the issue is related to narrowing the type of a variable in a broader scope?
2. Andrew Branch (andrewbranch)

   changed the title [-]Variable type isn't propagated out of a try block[/-] [+]`unknown` isn’t narrowed by assignment[/+] on Apr 9, 2021
3. andrewbranch commented on Apr 9, 2021

   

   Andrew Branch (andrewbranch)

   on Apr 9, 2021

   Member

   More actions

   I think this is probably a better example of what you’re surprised by, if I’m understanding you.

   👍React with 👍1Reacted by Emilio
4. JonathanDCohen commented on Apr 9, 2021

   

   Jonathan Cohen (JonathanDCohen)

   on Apr 9, 2021 via email

   Last edited by JonathanDCohen

   Author

   More actions

   Yes, that would do it.
5. Andrew Branch (andrewbranch)

   added

   Awaiting More FeedbackThis means we'd like to hear from more people who would be helped by this featureThis means we'd like to hear from more people who would be helped by this feature

   SuggestionAn idea for TypeScriptAn idea for TypeScript

   on Apr 9, 2021
6. emilioplatzer commented on Apr 22, 2021

   

   Emilio (emilioplatzer)

   on Apr 22, 2021

   More actions

   I my opinion you are confused about unknown. If you see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#new-unknown-top-type you can read:

   Anything is assignable to unknown, but unknown isn’t assignable to anything but itself and any without a type assertion or a control flow based narrowing. Likewise, no operations are permitted on an unknown without first asserting or narrowing to a more specific type.

   In your case you can use any to say I support any value. And then all works!

   function f(request: {params: {[param: string]: any;}}) {
       let x = request.params.x;
       try {
           x = validate(x);
       } catch (e) {}
   
       try {
           takesString(x);  // Fails to compile, x is of type unknown.
       } catch (e) {}
   }
   
   function validate(x: any): string { return ""; }
   function takesString(s: string) {}

   Look at Playground
7. JonathanDCohen commented on Apr 22, 2021

   

   Jonathan Cohen (JonathanDCohen)

   on Apr 22, 2021

   Last edited by JonathanDCohen

   Author

   More actions

   We lose type safety with any. In my case the type of params is used for all of our server's endpoint handlers, so using unknown is useful to make sure we don't skip a validation step. I think the true correct way to do this would be to do something like

   function validate(x: unknown): x is string {
     // blah blah blah...
   }
   // ...
   function f(request: {params: {[param: string]: unknown;}}) {
       let x = request.params.x;
       if (!validate(x)) { throw SomeError(); }
       // now x is narrowed to `string`
   }

   which is what I've switched to in my code.

   👍React with 👍2Reacted by Andrew Branch and Emilio
8. emilioplatzer commented on Apr 22, 2021

   

   Emilio (emilioplatzer)

   on Apr 22, 2021

   More actions

   I like your point:

   using unknown is useful to make sure we don't skip a validation step

   I think you are right. Here is anohter example that ilustrates it: Playground

   function validate(x: unknown): x is string {
       return typeof x === "string";
   }
   
   function mayBeNorS(): number|string{
       if(Math.random()>0.5) return 1;
       return 'x'
   }
   // ...
   function f(request: {params: {[param: string]: unknown;}}) {
       let x = request.params.x;
       if (!validate(x)) { throw Error('some'); }
       // now x is narrowed to `string`
       x = "other";
       // now x is ruined to `unknown`
       x.toLocaleLowerCase();
   
       // if the original variable was not `unkonwn` it works!
       let y = mayBeNorS();
       y = "other";
       // now y is narrowed to `string`
       y.toLocaleLowerCase();
   }
9. rChaoz commented on Sep 28, 2024

   

   Matei Trandafir (rChaoz)

   on Sep 28, 2024

   More actions

   Worth noting this also happens with {}, not just unknown