在 C++20 中删除协程的复制/移动函数并实例化它是否合法？

我注意到以下代码都被MSVC 和 GCC接受（下面是缩短的 TLDR 版本）：

template<typename T>
struct Generator {
    struct promise_type {
        std::suspend_always initial_suspend() {
            return {};
        }
        std::suspend_always final_suspend() noexcept {
            return {};
        }
        auto get_return_object() {
            return Generator{ std::coroutine_handle<promise_type>::from_promise(*this) };
        }

        std::suspend_always yield_value(T value) {
            current_value = value;
            return {};
        }
        void return_void() {}
        void unhandled_exception() {
            std::exit(1);
        }

        T current_value;
    };
    
    Generator(std::coroutine_handle<promise_type> h): coro(h) {}                

    std::coroutine_handle<promise_type> coro;
    
    ~Generator() {
        if (coro) coro.destroy();
    }
    Generator(const Generator&)              = delete;
    Generator& operator = (const Generator&) = delete;
    Generator(Generator&&)                   = delete;
    Generator& operator = (Generator&&)      = delete;

    T operator()() {
        coro.resume();
        return coro.promise().current_value;
    }

};

Generator<int> getNext() {
    int value = 0;
    while (true) {
        co_yield value;
        value++;
    }
}

int main() {
    Generator<int> gen = getNext();
    for (int i = 0; i <= 2; ++i) {
        int val = gen();
        std::cout << "val: " << val << std::endl;
    }
    
}

TLDR 版本：

template<typename T>
struct Generator {
    struct promise_type {
        //...
    };
    
    //...
    
    Generator(const Generator&)              = delete;
    Generator& operator = (const Generator&) = delete;
    Generator(Generator&&)                   = delete;
    Generator& operator = (Generator&&)      = delete;

    //...

};

Generator<int> getNext() {
    //...
}

int main() {
    Generator<int> gen = getNext();
    //...
}

但是，我想知道 C++20 标准是否允许这样做。通常，如果删除复制和移动函数，则函数无法检索类型：

struct MyType
{
    MyType() {}

    MyType(const MyType&)              = delete;
    MyType& operator = (const MyType&) = delete;
    MyType(MyType&&)                   = delete;
    MyType& operator = (MyType&&)      = delete;
};

MyType generateType()
{
    MyType val;
    return val; // <--- Compile Error
}

乍一看，这一行似乎也使用了已删除的函数： Generator<int> gen = getNext();

协程允许这样做吗？如果是，标准的哪一部分允许？