我开始实现 expected<E, T>根据建议，我遇到了问题。 在描述 monadic 功能 (5.9) 时，在 bind 中声明如果结果已经包装在上下文中 ( expected<E, T> )，则不应再次包装。

我如何实现它是 bind 有 2 个重载(使用 enable_if )，一个用于返回 expected 实例化的仿函数哪个实现没有将它包装在上下文中，而一个用于返回它所做的其他类型的那些。我遇到了一个问题，在调用者中没有值的情况下，非包装版本必须返回默认构造的 expected<E1, T1>这给出了预期的默认构造错误值。

这导致返回的 expected 的进一步延续会丢失导致默认构造的错误的上下文。

也许我应该处理被称为 is_same<expected<E,T>, functor_ret_type> 的上下文在这里，如果调用者出错，我可以转发“this”并保留错误的上下文，但这会导致仿函数返回 expected<E1, E2>返回 expected<E, expected<E1, E2>>

假设类如下:

E& error(); //returns the stored error
T& operator*(); //returns a reference to the stored value
bool has_value(); //returns true if the expected value is present, false if the error is present

这是我最初的实现方式:

//overload for wrapping functors
template<typename Functor>
auto bind(Functor functor) -> std::enable_if<is_instance<expected, 
                                             decltype(functor(**this))>::value,
                                             decltype(functor(**this))>::type
{
    using result_type = decltype(functor(**this));
    if (this->has_value())
    {
        return functor(**this);
    }
    return result_type();
}


//overload for non wrapping functors
template<typename Functor>
auto bind(Functor functor) -> std::enable_if<!is_instance<expected, 
                                             decltype(functor(**this))>::value,
                                             expected<E, decltype(functor(**this))>>::type
{
    using result_type = decltype(functor(**this));
    if (has_value())
    {
        return { functor(**this) };
    }
    return expected<E, result_type>(this->error());
}

在这里你可以看到，在第一个重载中，如果我们没有值，我们返回一个默认构造的 expected<E, T> functor 的类型返回，其中包含默认构造的错误类型 E ，这使我们失去了由于未调用仿函数而导致的原始错误的上下文。

如果我要将描述的行为解释为“如果仿函数返回 expected<E, T> 与调用绑定(bind)的类型相同，则不要换行，否则换行”，我们可以有以下实现:

//overload for wrapping functors
template<typename Functor>
auto bind(Functor functor) -> std::enable_if<is_same<expected<E, T>, 
                                             decltype(functor(**this))>::value,
                                             decltype(functor(**this))>::type
{
    if (this->has_value())
    {
        return functor(**this);
    }
    return *this;
}


//overload for non wrapping functors
template<typename Functor>
auto bind(Functor functor) -> std::enable_if<!is_same<expected<E, T>,
                                             decltype(functor(**this))>::value,
                                             expected<E, decltype(functor(**this))>>::type
{
    using result_type = decltype(functor(**this));
    if (has_value())
    {
        return { functor(**this) };
    }
    return expected<E, result_type>(this->error());
}

在这里，如果包装重载中没有值，我们转发 this这让我们知道最初的错误是什么，但是如果仿函数返回 expected<E1, T1>结果将是一个包裹 expected<E, expected<E1, T1>>

我能想到的第三种方法是只处理 E作为上下文，这会少一些限制，并允许打开一个返回 expected<E, T1> 的仿函数。 , 但是 expected<E1, T1> 的问题仍然存在。

哪种方法是正确的？也许我完全错过了另一种方法？

谢谢。

最佳答案

bind根据 unwrap 定义:

template <class Ex,class F>
’see below’ expected<E,T>::bind(F&& func)

Returns: - if bool(*this) returns unwrap(expected<E, decltype(func(move(val)))>(func(move(val)))), otherwise returns get_unexpected().

在https://isocpp.org/files/papers/n4015.pdf在http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4015.pdf unwrap只为 expected<E,expected<E,U>> 赋予重要语义;也就是说，两个意想不到的类型 E必须相同:

template <class E, class U>
constexpr expected<E,U> expected<E,expected<E,U>>::unwrap() const&;

Returns: - If bool(*this) then **this. else get_unexpected()

如果有两种不同的意外类型E1 , E2然后unwrap没有影响。

关于c++ - 根据提案 n4015 实现 expected<E, T>，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25781139/