function simpleGenerator() {
    yield 'A';
    yield 'B';
    yield 'C';
}

$gen = simpleGenerator();
foreach ($gen as $value) {
    echo $value; // 输出 ABC
}

function interactiveGen() {
    $received = yield 'Ready';
    yield "Received: $received";
}

$gen = interactiveGen();
echo $gen->current(); // Ready
$gen->send('Data');
echo $gen->current(); // Received: Data

class Scheduler {
    protected $queue;

    public function __construct() {
        $this->queue = new SplQueue();
    }

    public function newTask(Generator $coroutine) {
        $this->queue->enqueue($coroutine);
    }

    public function run() {
        while (!$this->queue->isEmpty()) {
            $task = $this->queue->dequeue();
            $task->send(null);
            
            if ($task->valid()) {
                $this->queue->enqueue($task);
            }
        }
    }
}

function asyncHttpRequest($url) {
    return new Promise(function($resolve) use ($url) {
        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_NOSIGNAL => 1,
        ]);
        
        curl_exec($ch);
        $resolve(curl_getinfo($ch, CURLINFO_HTTP_CODE));
        curl_close($ch);
    });
}

$scheduler->newTask(function() {
    $status = (yield asyncHttpRequest('https://api.example.com'));
    echo "Response status: $status\n";
});

class EventLoop {
    private $readStreams = [];
    private $writeStreams = [];
    private $timers = [];
    private $scheduled = [];

    public function addReadStream($stream, callable $callback) {
        $id = (int)$stream;
        $this->readStreams[$id] = [$stream, $callback];
    }

    public function addTimer($interval, callable $callback) {
        $time = microtime(true) + $interval;
        $this->timers[] = [$time, $callback];
    }

    public function run() {
        while (true) {
            $this->processTimers();
            $this->processStreams();
            $this->scheduleCoroutines();
        }
    }
}

function pipeline(array $stages) {
    return function($payload) use ($stages) {
        foreach ($stages as $stage) {
            $payload = yield from $stage($payload);
        }
        return $payload;
    };
}

$processing = pipeline([
    function($data) { yield processA($data); },
    function($data) { yield processB($data); },
    function($data) { yield processC($data); }
]);

yield $processing($inputData);

class CoroutinePool {
    private $maxWorkers;
    private $active = [];
    private $pending = [];

    public function __construct($maxWorkers = 10) {
        $this->maxWorkers = $maxWorkers;
    }

    public function submit(Generator $coroutine) {
        if (count($this->active) < $this->maxWorkers) {
            $this->startCoroutine($coroutine);
        } else {
            $this->pending[] = $coroutine;
        }
    }

    private function startCoroutine($coroutine) {
        $wrapper = function() use ($coroutine) {
            try {
                yield from $coroutine;
            } finally {
                $this->workerFinished();
            }
        };
        $this->active[] = $wrapper();
    }
}

function debugCoroutine(Generator $coroutine) {
    $ref = new ReflectionGenerator($coroutine);
    $trace = $ref->getTrace();
    
    echo "Current file: ".$ref->getExecutingFile()."\n";
    echo "Current line: ".$ref->getExecutingLine()."\n";
    print_r($trace);
}

function monitoredTask() {
    try {
        // 业务逻辑
    } catch (Throwable $e) {
        logException($e);
        yield rollbackOperation();
    }
}

Swoole\Runtime::enableCoroutine();

go(function () {
    $mysql = new Swoole\Coroutine\MySQL();
    $mysql->connect([
        'host' => '127.0.0.1',
        'user' => 'root',
        'password' => 'root',
        'database' => 'test',
    ]);
    
    $result = $mysql->query('SELECT * FROM users');
});

Swoole\Event::wait();

$loop = React\EventLoop\Factory::create();

$server = new React\Http\Server($loop, function (Psr\Http\Message\ServerRequestInterface $request) {
    return new React\Promise\Promise(function ($resolve) {
        $loop = React\EventLoop\Factory::create();
        
        $loop->addTimer(1, function () use ($resolve) {
            $response = new React\Http\Message\Response(
                200, ['Content-Type' => 'text/plain'], "Hello World"
            );
            $resolve($response);
        });
    });
});

$socket = new React\Socket\Server('0.0.0.0:8080', $loop);
$server->listen($socket);
$loop->run();