（日文/TS）为什么我的生成器函数代码在幂等性上有不同的行为？

问：

定义

下面是一个由 generator func 定义的惰性序列：

type Fn <T, R> = (p: T) => R ;

class Stream
<T> 
{
    
    constructor 
    (private readonly generatorFunction: () => Generator<T>) 
    {} ;
    
    
    static readonly iterate = 
    <T,> (initHead: T, f: Fn<T, T>)
    : Stream<T> => 
        
        new Stream
        ( function* ()
        : Generator<T> 
        {
            let head = initHead;
            while (true) 
            {
                yield head ;
                head = f(head);
            } ;
        } ) ;
    
    
    readonly map = 
    <R,> (f: Fn<T, R>)
    : Stream<R> => 
        
        new Stream
        (( function* (this: Stream<T>)
        : Generator<R> 
        {
            const iterator = this.generatorFunction() ;
            while (true) 
            {
                const { value: head, done } = iterator.next();
                if (done) break;
                
                yield f(head) ;
            } ;
        } ).bind(this)) ;
    
    
    
    readonly tookUntil = 
    (when: Fn<T, boolean>)
    : [T[], Stream<T>] => 
    {
        const result: T[] = [] ;
        const iterator = this.generatorFunction() ;
        
        while (true) 
        {
            const { value: head, done } = iterator.next();
            if (done) break;
            
            result.push(head);
            if (when(head)) break;
        } ;
        
        const drops = iterator ;
        
        return [result, new Stream
        (( function* (this: Stream<T>)
        : Generator<T> 
        {
            while (true) 
            {
                const { value, done } = drops.next();
                if (done) break;
                
                yield value ;
            }
        } ).bind(this)), ] ;
    } ;
    
    readonly took = 
    (limit: number)
    : [T[], Stream<T>] => 
    {
        if (limit < 1) 
        { return [[], this.follow({} as T).took(1)[1]] ; } else 
        {
            let count = 1;
            return this.tookUntil(() => !(count++ < limit));
        } ;
    } ;
    
    
    readonly takeUntil = 
    (when: Fn<T, boolean>)
    : T[] => 
        
        this.tookUntil(when)[0] ;
    
    readonly take = 
    (n: number)
    : T[] => 
        
        this.took(n)[0] ;
    
    
    readonly droppingUntil = 
    (when: Fn<T, boolean>)
    : Stream<T> => 
        
        this.tookUntil(when)[1] ;
    
    readonly dropping = 
    (limit: number)
    : Stream<T> => 
        
        this.took(limit)[1] ;
    
    
    
    readonly dropUntil = 
    (when: Fn<T, boolean>)
    : Stream<T> => 
        
        new Stream
        (( function* (this: Stream<T>)
        : Generator<T> 
        {
            const iterator = this.generatorFunction() ;
            
            while (true) 
            {
                const { value: head, done } = iterator.next();
                if (done) break;
                
                if (when(head)) { yield head ; break; } ;
            } ;
            
            while (true) 
            {
                const { value, done } = iterator.next();
                if (done) break;
                
                yield value ;
            } ;
        } ).bind(this)) ;
    
    readonly drop = 
    (limit: number)
    : Stream<T> => 
    {
        const the = this ;
        return new Stream(function* () 
        {
            if (limit < 1) 
            { yield* the.generatorFunction() ; } else 
            {
                let count = 1;
                yield* the.dropUntil(() => (count++ > limit));
            } ;
        }) ;
    } ;
    
    
    
    // some code not very important here ...
    
    
    
    [Symbol.iterator] = () => this.generatorFunction() ;
} ;

测试

直接实现的方法：drop

const droppedUntil = Stream.iterate(2, x => x + 1).dropUntil(x => x > 3) ;
console.log(droppedUntil.take(10)); // [4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
console.log(droppedUntil.take(10)); // [4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

const dropped = Stream.iterate(2, x => x + 1).drop(7) ;
console.log(dropped.take(10)); // [9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
console.log(dropped.take(10)); // [9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

实现方法如下：droppingtook

const dropped_bytook = Stream.iterate(2, x => x + 1).droppingUntil(x => !(x < 2)) ;
console.log(dropped_bytook.take(10)); // [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
console.log(dropped_bytook.take(10)); // [13, 14, 15, 16, 17, 18, 19, 20, 21, 22] ？？？？

还有其他一些有趣的事情......

const fibonacci = Stream.iterate([0, 1], ([a, b]) => [b, a + b]).map(([x]) => x) ;
console.log(fibonacci.take(6 + 4 + 2 + 4 + 2 + 4 + 2)); 
// [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657]

const xs = fibonacci.dropping(6).drop(4).map(x => [x]) ;
const xxs = fibonacci.dropping(6).map(x => [x]).drop(4) ;

console.log(xs.take(2)); // [[55], [89]] ： 10 dropped with map once, and ...
console.log(xs.take(2)); // [[987], [1597]] ： 4 more dropped with no more map before take ... 
console.log(xs.take(2)); // [[17711], [28657]] ； 4 more dropped with no more map before take ...

console.log(xxs.take(2)); // [[55], [89]] ： 10 dropped with map once, and ...
console.log(xxs.take(2)); // [[987], [1597]] ： 4 more dropped with no more map before take ... 
console.log(xxs.take(2)); // [[17711], [28657]] ； 4 more dropped with no more map before take ...


const ys = fibonacci.dropping(6).dropping(4).map(x => [x]) ;
const yys = fibonacci.dropping(6).map(x => [x]).dropping(4) ;

console.log(ys.take(2)); // [[55], [89] ： 10 dropped with map once, and ...
console.log(ys.take(2)); // [[144], [233]] ： just take 2 then, no more dropped ...
console.log(ys.take(2)); // [[377], [610]]] ： just take 2 then, no more dropped ...

console.log(yys.take(2)); // [[55], [89] ： 10 dropped with map once, and ...
console.log(yys.take(2)); // [[144], [233]] ： just take 2 then, no more dropped ...
console.log(yys.take(2)); // [[377], [610]]] ： just take 2 then, no more dropped ...

const zs = fibonacci.dropping(5).map(x => [x]).drop(4).dropping(1) ;
const zzs = fibonacci.dropping(6).map(x => [x]).drop(4).dropping(0) ;

console.log(zs.take(2)); // [[55], [89] ： 10 dropped with map once, and ...
console.log(zs.take(2)); // [[144], [233]] ： just take 2 then, no more dropped ...
console.log(zs.take(2)); // [[377], [610]]] ： just take 2 then, no more dropped ...

console.log(zzs.take(2)); // [[55], [89] ： 10 dropped with map once, and ...
console.log(zzs.take(2)); // [[144], [233]] ： just take 2 then, no more dropped ...
console.log(zzs.take(2)); // [[377], [610]]] ： just take 2 then, no more dropped ...

总结

所以，有两种类型：Stream

• 一个是看起来不可变的：它的方法没有副作用。take
• 如果你通过：它的方法对实例本身有副作用，那么它看起来是可变的。droppingtakestream

问题是，为什么返回的流或看起来不纯净，而所有由其他方法返回的流也由相同的形式 new Stream（（ function* （this： Stream<T>）： Generator<T> { /* ...一些产量 ... */ } ）.bind（this）） 不会对此实例本身产生副作用。taketooktookUntiltake

我在 TS Playground （v5.1.6） 上尝试了所有代码，这是我的测试：https://tsplay.dev/Wklk0w。

我刚才已经阅读了迭代器助手，所以我知道我的实现可能很丑陋......

(语言相同的问题 zh-cn)