About LazyPromise

[4kangjc]

async_simple/async_simple/coro/Lazy.h

Lines 119 to 184 in aa1d718

	template <typename T>
	class LazyPromise : public LazyPromiseBase {
	public:
	LazyPromise() noexcept {}
	~LazyPromise() noexcept {}
	Lazy<T> get_return_object() noexcept;
	template <typename V>
	void return_value(V&& value) noexcept(
	std::is_nothrow_constructible_v<
	T, V&&>) requires std::is_convertible_v<V&&, T> {
	_value.template emplace<T>(std::forward<V>(value));
	}
	void unhandled_exception() noexcept {
	_value.template emplace<std::exception_ptr>(std::current_exception());
	}
	public:
	T& result() & {
	if (std::holds_alternative<std::exception_ptr>(_value))
	AS_UNLIKELY {
	std::rethrow_exception(std::get<std::exception_ptr>(_value));
	}
	assert(std::holds_alternative<T>(_value));
	return std::get<T>(_value);
	}
	T&& result() && {
	if (std::holds_alternative<std::exception_ptr>(_value))
	AS_UNLIKELY {
	std::rethrow_exception(std::get<std::exception_ptr>(_value));
	}
	assert(std::holds_alternative<T>(_value));
	return std::move(std::get<T>(_value));
	}
	Try<T> tryResult() noexcept {
	if (std::holds_alternative<std::exception_ptr>(_value))
	AS_UNLIKELY { return Try<T>(std::get<std::exception_ptr>(_value)); }
	else {
	assert(std::holds_alternative<T>(_value));
	return Try<T>(std::move(std::get<T>(_value)));
	}
	}
	std::variant<std::monostate, T, std::exception_ptr> _value;
	};
	template <>
	class LazyPromise<void> : public LazyPromiseBase {
	public:
	Lazy<void> get_return_object() noexcept;
	void return_void() noexcept {}
	void unhandled_exception() noexcept {
	_exception = std::current_exception();
	}
	void result() {
	if (_exception != nullptr)
	AS_UNLIKELY { std::rethrow_exception(_exception); }
	}
	Try<void> tryResult() noexcept { return Try<void>(_exception); }
	public:
	std::exception_ptr _exception{nullptr};
	};

感觉这里和Try差不多，有没有考虑将数据成员直接写成Try<T>呢，直接用Try也会简洁一些？很多代码可以合并，除了return_xxx的，将相同逻辑代码移至LazyPromiseBase？差不多最后只留一个return_xxx

[ChuanqiXu9]

我感觉可以试试？

[4kangjc]

template <typename T>
class LazyPromise : public LazyPromiseBase {
public:
    LazyPromise() noexcept {}
    ~LazyPromise() noexcept {}

    Lazy<T> get_return_object() noexcept;

    template <typename V>
    void return_value(V&& value) noexcept(
        std::is_nothrow_constructible_v<
            T, V&&>) requires std::is_convertible_v<V&&, T> {
        _value.emplace(std::forward<V>(value));
    }
    void unhandled_exception() noexcept {
        _value.setException(std::current_exception());
    }

public:
    T& result() & {
        return _value.value();
    }
    T&& result() && {
        return std::move(_value).value();
    }

    Try<T> tryResult() noexcept {
        return std::move(_value);
    }
    Try<T> _value;
};

template <>
class LazyPromise<void> : public LazyPromiseBase {
public:
    Lazy<void> get_return_object() noexcept;
    void return_void() noexcept {}
    void unhandled_exception() noexcept {
        _value.setException(std::current_exception());
    }

    void result() {
        return _value.value();
    }
    Try<void> tryResult() noexcept { 
        return std::move(_value);
    }

public:
    Try<void> _value;
};

[4kangjc]

放在LazyPromiseBase怪怪的