State of the spec ? + useful example #10

Activity

1. Pyrolistical commented on Dec 16, 2021

   

   Pyrolistical

   on Dec 16, 2021

   More actions

   why couldn't you just pass that into the iterator?

   export interface IGetPaginatedDataOptions {
     signal?: AbortSignal;
   }
   
   export class Pagination<GData> {
     getPaginatedData(page: IPageInfo, options?: IGetPaginatedDataOptions): Promise<IPaginatedData<GData>> {
       return fetch('some url', options).then(_ => _.json());
     }
   
     /**
      * Creates an async iterator over the list of pages
      */
     async* pageIterator(controller, { pageIndex = 0, itemsPerPage = 10 }: Partial<IPageInfo> = {}): AsyncGenerator<IPaginatedData<GData>, any, any> {
       const page: IPageInfo = { pageIndex, itemsPerPage };
       let result: IPaginatedData<GData>;
       do {
         result = await this.getPaginatedData(page, controller);
         yield result;
         page.pageIndex++;
       } while (result.pageCount > page.pageIndex);
     }
   }
   
   const controller = new AbortController();
   const pagination = new Pagination().pageIterator(controller);
   setTimeout(() => controller.abort('timeout'), 5000);
   const page = await pagination.next();
2. lifaon74 commented on Dec 18, 2021

   

   lifaon74

   on Dec 18, 2021

   Author

   More actions

   In my example, the purpose is to cancel individually the request, not the whole iteration

   👍React with 👍1Reacted by Pyrolistical
3. hax commented on May 25, 2022

   

   hax

   on May 25, 2022

   Member

   More actions

   @lifaon74 Thank you for the wonderful example.

   I'm planning update the proposal in next TC39 meeting.

   My idea is moving from function.sent meta property to receive parameter. So your example would become:

   ...
     /**
      * Creates an async iterator over the list of pages
      */
     async* pageIterator({ pageIndex = 0, itemsPerPage = 10 } = {}) 
         receive (signal: AbortSignal) {
       const page = { pageIndex, itemsPerPage };
       let result: IPaginatedData<GData>;
       do {
         result = await this.getPaginatedData(page, {signal});
         yield result;
         page.pageIndex++;
       } while (result.pageCount > page.pageIndex);
     }
   ...
   const page = await pagination.next(controller.signal) // only send signal to avoid exposing too many power (like .abort())

   I think this example also show some merits of receive param than function.sent.

   First, the information is on the method signature now. In the function.sent version, we can't see the generator could have extra option. We need to go through the method body and check the existence of function.sent or x = yield pattern.

   Second, even we see await this.getPaginatedData(page, function.sent), it's unclear what function.sent is for, so we need to follow getPaginatedData definition and guess what function.sent give us. On the other side, receive parameter is just a parameter, so it could has a descriptive name and type annotation directly (or even parameter decorators in the future).

   Third, it also allow TS infer the return type of the generator function so I removed the wordy return type (See #13 ).

   I hope this direction could be approved by the committee, and help your use cases :-)