c++ yild?

// infiniteDataStream.cpp

#include <coroutine>
#include <memory>
#include <iostream>

template<typename T>
struct Generator {
    
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;
    
    Generator(handle_type h): coro(h) {}                         // (3)
    handle_type coro;
    std::shared_ptr<T> value;
    
    ~Generator() {
        if ( coro ) coro.destroy();
    }
    Generator(const Generator&) = delete;
    Generator& operator = (const Generator&) = delete;
    Generator(Generator&& oth): coro(oth.coro) {
        oth.coro = nullptr;
    }
    Generator& operator = (Generator&& oth) {
        coro = oth.coro;
        oth.coro = nullptr;
        return *this;
    }
    int getValue() {
        return coro.promise().current_value;
    }
    bool next() {                                                // (5)
        coro.resume();
        return not coro.done();
    }
    struct promise_type {
        promise_type()  = default;                               // (1)
          
        ~promise_type() = default;
        
        auto initial_suspend() {                                 // (4)
            return std::suspend_always{};
        }
        auto final_suspend() {
            return std::suspend_always{};
        }
        auto get_return_object() {                               // (2)
            return Generator{handle_type::from_promise(*this)};
        }
        auto return_void() {
            return std::suspend_never{};
        }
      
        auto yield_value(int value) {                            // (6) 
            current_value = value;
            return std::suspend_always{};
        }
        void unhandled_exception() {
            std::exit(1);
        }
        T current_value;
    };

};

Generator<int> getNext(int start = 0, int step = 1){
    auto value = start;
    for (int i = 0;; ++i){
        co_yield value;
        value += step;
    }
}

int main() {
    
    std::cout << std::endl;
  
    std::cout << "getNext():";
    auto gen = getNext();
    for (int i = 0; i <= 10; ++i) {
        gen.next();
        std::cout << " " << gen.getValue();                      // (7)
    }
    
    std::cout << "\n\n";
    
    std::cout << "getNext(100, -10):";
    auto gen2 = getNext(100, -10);
    for (int i = 0; i <= 20; ++i) {
        gen2.next();
        std::cout << " " << gen2.getValue();
    }
    
    std::cout << std::endl;
    
}

getNext(): 0 1 2 3 4 5 6 7 8 9 10

getNext(100, -10): 100 90 80 70 60 50 40 30 20 10 0 -10 -20 -30 -40 -50 -60 -70 -80 -90 -100

//data[nx][ny][nz];
for(auto&&[i,j,k,var] : pass<3>(data)){
  //var = data[i][j][k];
  //do stuff
}

template<int n, int d>
struct foo_t{
	//n -- число измерений
	//d -- размер аргумента form_t 
	//data[nx][ny][nz]
	/* ... */
	void inline operator ()(const form_t<d> cfs[]){
		/* ... */
		if constexpr(n==3){
			for(auto&&[i,x] : cfs[0]){ //d-раз
			for(auto&&[j,y] : cfs[1]){ //d-раз
			for(auto&&[k,z] : cfs[2]){ //d-раз
				auto cff = x*y*z;
				auto var = data[i][j][k];
				//do stuff with var
			}}}
			return;
		}
		/* ... */
	}
};

constexpr int n = 3, d=4;
foo_t<n,d> foo;
form_t<d> forms[n];
for(auto&&[cff,var] : pass(foo, cfs){
	//do stuff
}

template<int d>
struct form_t{
	int   id;
	float cf[d];

	struct iterator; //возвращает пару {int, float}
	iterator begin() const;
	iterator end()   const;
};

out += var*cff

var += cff*аргумент

	void inline operator ()(const form_t<d> cfs[]){
		/* ... */
		if constexpr(n==3){
			for(auto&&[i,x] : cfs[0]){ //d-раз
			for(auto&&[j,y] : cfs[1]){ //d-раз
			for(auto&&[k,z] : cfs[2]){ //d-раз
				auto cff = x*y*z;
				auto var = data[i][j][k];
				//do stuff with var
			}}}
			return;
		}
		/* ... */
	}

auto pass2(auto && data, auto forms, auto && on) {
  std::span cfs{forms};
  for(auto && [idx, cf]: cfs[0]) {
    auto && data0 = data[idx]; auto && cff0 = cf;
    for(auto && [idx, cf]: cfs[1]) {
      auto && data1 = data0[idx]; auto && cff1 = cff0 * cf;
      for(auto && [idx, cf]: cfs[2]) {
        auto && data2 = data1[idx]; auto && cff2 = cff1 * cf;
        on(cff2, data2);
      }
    }
  }
}