Generator

function* generator() {
  yield 'hello';
  yield 'world';
}

package main
 
import (
	"fmt"
	"iter"
)
 
// Generator trả về một iter.Seq — kiểu "range-over-func" chuẩn của Go.
// Caller range trực tiếp qua nó.
func Generator() iter.Seq[string] {
	return func(yield func(string) bool) {
		for _, v := range []string{"hello", "world"} {
			if !yield(v) {
				return
			}
		}
	}
}

// Iterator của Rust vốn đã "pull": from_fn nhận một closure giữ state
// riêng và trả Option<T> mỗi lần gọi — gần nhất với generator viết tay.
fn generator() -> impl Iterator<Item = &'static str> {
    let mut state = 0;
    std::iter::from_fn(move || {
        state += 1;
        match state {
            1 => Some("hello"),
            2 => Some("world"),
            _ => None,
        }
    })
}

// AsyncStream: closure gọi yield() cho từng giá trị, finish() khi xong —
// gần nhất với `yield` thật trong 5 ngôn ngữ này.
func generator() -> AsyncStream<String> {
    AsyncStream { continuation in
        continuation.yield("hello")
        continuation.yield("world")
        continuation.finish()
    }
}

// Chạy phần thân generator trên một virtual thread (JEP 444, Java 21);
// mỗi lần next() được gọi sẽ chặn cho tới khi thread kia gửi giá trị
// tiếp theo qua SynchronousQueue — mô phỏng `yield` chặn (blocking).
static class Generator implements Iterable<String>, Iterator<String> {
    private static final Object DONE = new Object();
    private final SynchronousQueue<Object> queue = new SynchronousQueue<>();
    private Object peeked;
 
    Generator() {
        Thread.ofVirtual().start(() -> {
            send("hello");
            send("world");
            send(DONE);
        });
    }
 
    private void send(Object value) {
        try {
            queue.put(value);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
 
    @Override
    public boolean hasNext() {
        if (peeked == null) {
            try {
                peeked = queue.take();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
        return peeked != DONE;
    }
 
    @Override
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        String value = (String) peeked;
        peeked = null;
        return value;
    }
 
    @Override
    public Iterator<String> iterator() {
        return this;
    }
}

const gen = generator();
 
while (true) {
  const { value, done } = gen.next();
  console.log(value, done);
 
  if (done) {
    break;
  }
}
// hello false
// world false
// undefined true

func main() {
	// iter.Pull chuyển một iter.Seq kiểu "push" thành cặp next/stop kiểu
	// "pull" — cách gần nhất với việc tự gọi gen.next().
	next, stop := iter.Pull(Generator())
	defer stop() // luôn gọi stop, kể cả khi sequence đã chạy hết
 
	for {
		v, ok := next()
		if !ok {
			break
		}
		fmt.Println(v)
	}
	// hello
	// world
}

fn main() {
    // Iterator vốn đã "pull": gọi .next() trực tiếp, không cần chuyển đổi
    // gì thêm (khác với Go, phải dùng iter.Pull để có next/stop).
    // (đặt tên `it` vì `gen` là từ khoá dành riêng từ edition 2024)
    let mut it = generator();
 
    while let Some(value) = it.next() {
        println!("{value}");
    }
    // None đóng vai trò done: true khi vòng lặp dừng
    // hello
    // world
}

// makeAsyncIterator() lấy iterator thủ công; next() trả nil khi hết —
// đóng vai trò done: true.
do {
    var iterator = generator().makeAsyncIterator()
 
    while let value = await iterator.next() {
        print(value)
    }
}
// hello
// world

void main() {
    // hasNext()/next() chuẩn của Java: hasNext() chặn cho tới khi có giá
    // trị tiếp theo hoặc generator báo xong.
    Generator gen = new Generator();
 
    while (gen.hasNext()) {
        IO.println(gen.next());
    }
    // hello
    // world
}

for (const value of generator()) {
  console.log(value);
}
// hello
// world
 
// generator object cũng là iterator, nên iterator helpers biến đổi được
// trực tiếp, không cần spread ra mảng trước
for (const value of generator().map((word) => word.toUpperCase())) {
  console.log(value);
}
// HELLO
// WORLD

// channelGenerator mô phỏng generator bằng một goroutine gửi giá trị qua
// channel, đóng lại khi xong — cách kinh điển để lấy từng giá trị một.
func channelGenerator() chan string {
	c := make(chan string)
 
	go func() {
		defer close(c)
		c <- "hello"
		c <- "world"
	}()
 
	return c
}
 
func main() {
	for value := range Generator() {
		fmt.Println(value)
	}
	// hello
	// world
 
	// cách khác: dùng channel kiểu kinh điển
	for value := range channelGenerator() {
		fmt.Println(value)
	}
	// hello
	// world
}

fn main() {
    for value in generator() {
        println!("{value}");
    }
    // hello
    // world
 
    // Iterator có sẵn .map()/.filter()/... từ bản 1.0 — lâu trước cả
    // iterator helpers của JS (Node 22) hay Go (1.23).
    for value in generator().map(|w| w.to_uppercase()) {
        println!("{value}");
    }
    // HELLO
    // WORLD
}

for await value in generator() {
    print(value)
}
// hello
// world
 
// AsyncStream tuân theo AsyncSequence nên có .map() giống Sequence thường
for await value in generator().map({ $0.uppercased() }) {
    print(value)
}
// HELLO
// WORLD

void main() {
    for (String value : new Generator()) {
        IO.println(value);
    }
    // hello
    // world
 
    // Iterator/Iterable của Java không có .map() dựng sẵn: chuyển qua
    // Stream trước rồi mới biến đổi được.
    StreamSupport.stream(new Generator().spliterator(), false)
            .map(String::toUpperCase)
            .forEach(IO::println);
    // HELLO
    // WORLD
}