From 8dc627818317d258714f726b7dacbdbf0d987a78 Mon Sep 17 00:00:00 2001
From: ASDAlexander77 <duzhar@googlemail.com>
Date: Tue, 27 Oct 2026 13:43:19 +0000
Subject: [PATCH] -mm=own: the lazy iterator helpers take their source over

take, filter and map say @keeps, and drop becomes a @keeps generator, so under -mm=own the
generator's state owns the iterator (and the callback) and the result can be stored or returned.
Needs the compiler's @keeps on generators.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/generics/lib.generics.ts | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/generics/lib.generics.ts b/src/generics/lib.generics.ts
index 78c73fa..e5d3055 100644
--- a/src/generics/lib.generics.ts
+++ b/src/generics/lib.generics.ts
@@ -1474,6 +1474,10 @@ namespace __Iterator
     // example how to restrict to iterators only
     // function *take<TIter extends { next(): {value: any, done: boolean} >(iter: TIter, limit: index) {
 
+    // The lazy helpers take their source over, as in JavaScript: under -mm=own `@keeps` makes the
+    // generator's state own `iter` (and the callback), so `const seq = g().map(f)` may be kept. The
+    // other models ignore it.
+    @keeps("iter")
     function *take<TIter extends { next(): {value: any, done: boolean} } >(iter: TIter, limit: index) {
         let count: index = 0;
         for (const v of iter) {
@@ -1483,11 +1487,14 @@ namespace __Iterator
         }
     }
 
-    function drop<TIter extends { next(): {value: any, done: boolean} } >(iter: TIter, limit: index) {
-        for (let i: index = 0; i < limit; i++)
-            iter.next();
-
-        return iter;
+    @keeps("iter")
+    function *drop<TIter extends { next(): {value: any, done: boolean} } >(iter: TIter, limit: index) {
+        let count: index = 0;
+        for (const v of iter) {
+            if (count++ < limit)
+                continue;
+            yield v;
+        }
     }
 
     type ElementType<T> = T extends { next(): {value: infer TElem, done: boolean} } ? TElem : never;  
@@ -1500,6 +1507,7 @@ namespace __Iterator
         return true;
     }    
 
+    @keeps("iter", "callbackFn")
     function *filter<TIter extends { next(): {value: any, done: boolean} }>(iter: TIter, callbackFn: (e: ElementType<TIter>) => boolean) {
         for (const v of iter) {
             if (!callbackFn(v)) 
@@ -1517,6 +1525,7 @@ namespace __Iterator
         for (const v of iter) callbackFn(v);
     }     
 
+    @keeps("iter", "callbackFn")
     function *map<TIter extends { next(): {value: any, done: boolean} }, R>(iter: TIter, callbackFn: (e: ElementType<TIter>) => R) {
         for (const v of iter) yield callbackFn(v);
     }