Activity

1. gcnew commented on Aug 11, 2016

   

   Marin Marinov (gcnew)

   on Aug 11, 2016

   Last edited by gcnew

   Contributor

   More actions

   Strictly speaking - no. It doesn't guard against sparse arrays, e.g:

   const arr: number[] = [];
   arr[1] = 5;
   if (arr.length) {
       arr.shift(); // undefined
   }
   arr.shift(); // 5

   Then again, the true type of indexing is also T | undefined.
2. normalser commented on Aug 11, 2016

   

   normalser

   on Aug 11, 2016

   Last edited by normalser

   Author

   More actions

   Marin Marinov (@gcnew) Thanks for the explanation, but then shouldn't accessing sparse arrays and having --strictNullChecks on - always return T | undefined

   args[Number.MAX_VALUE] // type: 'string'
3. gcnew commented on Aug 11, 2016

   

   Marin Marinov (gcnew)

   on Aug 11, 2016

   Last edited by gcnew

   Contributor

   More actions

   @wallverb Yes, well and truly. It was done for convenience as explained by the reply to #7140 (comment)

   PS: To play devil's advocate, I guess the return type of shift() is written as T | undefined to accommodate for shifting an empty array, no so much about the sparse case. In this sense you are right, but it would be very hard to create a generic solution that takes into account all the hidden, intricate knowledge of an objects state and apply it to it's methods.

   👍React with 👍1Reacted by normalser
4. normalser commented on Aug 11, 2016

   

   normalser

   on Aug 11, 2016

   Author

   More actions

   wow, interesting, thank you so much for finding that comment for me. I wish such knowledge was more easily accessible/findable :)
5. normalser

   closed this as completedon Aug 11, 2016
6. gcnew commented on Aug 11, 2016

   

   Marin Marinov (gcnew)

   on Aug 11, 2016

   Contributor

   More actions

   BTW: as a workaround this works:

   function isShiftable<T>(arr: T[]): arr is Array<T> & { shift(): T; } {
       return !!arr.length;
   }
   
   const arr: number[] = [5];
   if (isShiftable(arr)) {
       const x = arr.shift(); // x is of type `number`
   }

   👍React with 👍1Reacted by normalser
7. Ryan Cavanaugh (RyanCavanaugh)

   added

   QuestionAn issue which isn't directly actionable in codeAn issue which isn't directly actionable in code

   on Aug 11, 2016
8. dlmanning commented on Sep 25, 2016

   

   David Manning (dlmanning)

   on Sep 25, 2016

   Last edited by dlmanning

   More actions

   This workaround is not working for me.

   function isNotEmpty<T>(arr: T[]): arr is Array<T> & { pop(): T; } {
       return arr.length > 0;
   }
   
   function doSomething () {
     const stack: Vertex[] = []
     const groups: string[] = []
   
     // put some things on the stack
   
     while (isNotEmpty(stack)) {
       const v = stack.pop() // v is still typed as Vertex | undefined
       groups.push(v.id) // [ts] Object is possibly 'undefined'
     }
   }

   did I miss something?

   (tried this with typescript 2.0.3 and 2.1.0-dev.20160924)

   Update: changed the order of the return type def like so:

   function isNotEmpty<T>(arr: T[]): arr is { pop(): T; } & Array<T>

   and it works as desired. Is the type intersection operator not commutative?
9. gcnew commented on Sep 25, 2016

   

   Marin Marinov (gcnew)

   on Sep 25, 2016

   Last edited by gcnew

   Contributor

   More actions

   David Manning (@dlmanning) You are right, the suggested fix is the the way to go. It should be noted though that this type guard is a hack - I just found that it worked. About the type intersection operator I don't think there is a notion of commutativity, I suspect it's just the compiler picking the first matching declaration.
10. microsoft

    locked and limited conversation to collaborators on Jun 19, 2018