Generators และ yield

Generator มีทั้งสองภาษา แต่ Python พึ่งพาหนักกว่ามาก

TypeScript ก็มี generator เหมือนกัน function* คู่กับ yield ทำงานคล้ายกันมากเมื่อมองผ่าน ๆ คือได้ lazy iterator เรียก .next() ได้ และ function หยุดค้างไว้ระหว่าง yield

แต่ใน Python generator ไม่ใช่ฟีเจอร์เฉพาะกลุ่ม เพราะฝังอยู่ทั่ว standard library ทั้ง range(), การวนอ่านไฟล์, zip(), map(), filter() และ module itertools ล้วนคืน lazy iterator ที่ยืนอยู่บน generator protocol ตัวเดียวกัน แม้แต่ async/await ก็สร้างทับ generator อยู่ข้างใน เข้าใจ generator ของ Python ได้ ก็เท่ากับเข้าใจแกนสำคัญของภาษาไปแล้วครึ่งหนึ่ง

การสร้างและใช้งาน generator

generator ของ Python คือ function ใดก็ตามที่มีคำสั่ง yield อยู่ การเรียก function นั้นจะคืนค่า generator object — โค้ดจะยังไม่ทำงานจนกว่าคุณจะวนซ้ำ

// TypeScript generator with function*
function* countUp(start: number, stop: number): Generator<number> {
  let current = start;
  while (current <= stop) {
    yield current;
    current++;
  }
}

const gen = countUp(1, 5);
for (const val of gen) {
  process.stdout.write(val + " ");
}
console.log();

// Infinite generator
function* fibonacci(): Generator<number> {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fib = fibonacci();
const firstTen = Array.from({ length: 10 }, () => fib.next().value);
console.log(firstTen);

# Python generator with def + yield
def count_up(start, stop):
    current = start
    while current <= stop:
        yield current
        current += 1

gen = count_up(1, 5)
for val in gen:
    print(val, end=" ")
print()

# Infinite generator
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
first_ten = [next(fib) for _ in range(10)]
print(first_ten)

ข้อแตกต่างสำคัญที่ควรสังเกต:

Python ใช้ def ธรรมดา ไม่มี syntax แบบ function* ขอแค่มี yield โผล่ที่ไหนสักแห่งใน function body function นั้นก็กลายเป็น generator ทันที
ลูป for ของ Python ทำงานได้โดยตรงกับ iterable ทุกชนิด รวมถึง generator โดยไม่ต้องเรียก .next() เอง
TypeScript ต้องระบุ return type เป็น Generator<T> แต่ Python จะอนุมานให้โดยอัตโนมัติ

การสื่อสารสองทางด้วย send()

generator ของ Python รองรับการส่งข้อมูลสองทาง คุณสามารถส่งค่ากลับเข้าไปใน generator ที่หยุดอยู่โดยใช้ .send() ค่าที่ส่งไปจะกลายเป็นผลลัพธ์ของ expression yield ภายใน generator TypeScript รองรับสิ่งนี้ผ่าน gen.next(value) แต่ฟีเจอร์นี้ไม่ค่อยถูกใช้ใน ecosystem ของ TS

// TypeScript: sending values into a generator
function* accumulator(): Generator<number, void, number> {
  let total = 0;
  while (true) {
    const value = yield total;
    if (value === undefined) break;
    total += value;
  }
}

const acc = accumulator();
acc.next();        // prime the generator
console.log(acc.next(10).value); // 10
console.log(acc.next(20).value); // 30
console.log(acc.next(5).value);  // 35

# Python: sending values into a generator with .send()
def accumulator():
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)           # prime the generator (advance to first yield)
print(acc.send(10)) # 10
print(acc.send(20)) # 30
print(acc.send(5))  # 35

ลองด้วยตัวเอง

Open in an online REPL

def count_up(start, stop):
    current = start
    while current <= stop:
        yield current
        current += 1

gen = count_up(1, 5)
for val in gen:
    print(val, end=" ")
print()

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
first_ten = [next(fib) for _ in range(10)]
print(first_ten)

🟦 Generator protocol: __iter__ และ __next__

เวลาลูป for ของ Python วนบน object ใดก็ตาม เบื้องหลังจะเรียก dunder method สองตัวนี้:

__iter__(self) — เรียกครั้งเดียวเพื่อขอ iterator object ถ้าเป็น generator จะคืน self กลับมา
__next__(self) — เรียกซ้ำไปเรื่อย ๆ เพื่อขอค่าถัดไป พอ generator หมดค่าก็ raise StopIteration เป็นสัญญาณให้ลูป for หยุด

generator object implement ทั้งสองตัวนี้ให้อัตโนมัติ และคุณเขียน protocol นี้เองใน class ไหนก็ได้ เพื่อทำให้ class นั้น iterable:

class CountUp:
    def __init__(self, start, stop):
        self.current = start
        self.stop = stop

    def __iter__(self):
        return self  # the iterator is the object itself

    def __next__(self):
        if self.current > self.stop:
            raise StopIteration
        val = self.current
        self.current += 1
        return val

for v in CountUp(1, 5):
    print(v)

นี่คือสิ่งที่ generator ช่วยให้คุณไม่ต้องเขียนด้วยมือ

yield from สำหรับการมอบหมาย

yield from จะมอบหมายการวนซ้ำให้กับ iterable อื่น โดยส่งต่อแต่ละค่าผ่านไปโดยไม่ต้องเขียนลูปด้วยตนเอง:

def chain(*iterables):
    for it in iterables:
        yield from it

list(chain([1, 2], [3, 4], [5]))  # [1, 2, 3, 4, 5]

yield from ยังส่งต่อ .send() และ .throw() ลงไปยัง inner generator ด้วย นี่คือกลไกที่ asyncio เคยใช้ต่อ coroutine เข้าด้วยกัน ก่อนที่ syntax async/await จะเข้ามา