def csv_reader(file_name):
    for row in open(file_name, "r"):
        yield row
for line in csv_reader("abc.csv"):
    print(line)

def csv_reader(file_name):
    for row in open(file_name, "r"):
        yield row
def line_reader(str):
    for c in str:
        yield c;
for line in csv_reader("abc.csv"):
    for x in line_reader(line):
        print(x)

#include <coroutine>
#include <iostream>
#include <optional>
template<std::movable T>
class Lazy {
public:
    // Объект типа promise_type создаётся первым делом при запуске корутины.
    // Он содержит обработчики всевозможных событий корутины.
    struct promise_type {
        // Этот метод вызывается в начале работы корутины.
        // Он конструирует «традиционное» возвращаемое значение —
        // то, что сразу же получает функция, вызвавшая корутину.
        Lazy<T> get_return_object() {
            return Lazy{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        // Этот метод вызывается при старте корутины. Он определяет,
        // будет ли она выполняться сразу, или начнёт с приостановки.
        // std::suspend_always означает приостановку
        static std::suspend_always initial_suspend() noexcept { return {}; }
        // Этот метод вызывается при завершении корутины.
        static std::suspend_always final_suspend() noexcept { return {}; }
        // Это обработчик события co_return. Ему передаётся то, что
        // корутина хочет вернуть.
        std::suspend_never return_value(T value) noexcept {
            current_value = std::move(value);
            return {};
        }
        // Обработчик исключений также обязательно реализовывать.
        [[noreturn]]
        static void unhandled_exception() {
            throw;
        }
        // Сюда будем сохранять возвращённые значения.
        // Можем добавить любые поля по своему желанию.
        std::optional<T> current_value;
    };
    // Объект будет конструировать promise_type в методе get_return_object.
    // Опишем все конструкторы.
    explicit Lazy(const std::coroutine_handle<promise_type> coroutine) :
        m_coroutine{coroutine} {
    }
    Lazy(Lazy&& other) noexcept :
        m_coroutine{std::exchange(other.m_coroutine, {})}
    {
    }
    Lazy(const Lazy&) = delete;
    Lazy& operator=(const Lazy&) = delete;
    // В деструкторе нужно не забыть жёстко прервать корутину, чтобы
    // предотвратить утечку памяти, если значение осталось невостребованным.
    ~Lazy() {
        if (m_coroutine) {
            m_coroutine.destroy();
        }
    }
    // Этот метод мы добавили для того, чтобы получить значение из корутины.
    T get_value() {
        // Если значения нет, дадим корутине команду поработать
        if (!m_coroutine.promise().current_value)
            m_coroutine.resume();
        return std::move(*m_coroutine.promise().current_value);
    }
private:
    // Хендлер, который нам дал promise_type при конструировании
    std::coroutine_handle<promise_type> m_coroutine;
};
template<std::integral T>
Lazy<T> lazy_sum(T x, T y) {
    std::cout << "[sum performed]" << std::flush;
    co_return x + y;
}
int main() {
    // Запускаем корутину, но она сразу же
    // приостанавливается и ничего не суммирует
    Lazy<int> x = lazy_sum(42, 58);
    // Вызов get_value() отдаёт команду возобновления
    std::cout << "Computed sum: " << x.get_value() << std::endl;
    // Вывод: Computed sum: [sum performed]100
}