如何展平嵌套的 std::optional？

Question

注意：这个问题被简要标记为this的重复，但它不是一个完全重复的，因为我专门询问 std::optionals 。如果您关心一般情况，仍然是一个值得阅读的好问题。

假设我有嵌套的选项，像这样（愚蠢的玩具示例）：

struct Person{
    const std::string first_name;
    const std::optional<std::string> middle_name;
    const std::string last_name;
};
struct Form{
    std::optional<Person> person;
};

和这个垃圾邮件功能：

void PrintMiddleName(const std::optional<Form> form){
    if (form.has_value() && form->person.has_value() && form->person->middle_name.has_value()) {
        std::cout << *(*(*form).person).middle_name << std::endl; 
    } else {
        std::cout << "<none>"  << std::endl; 
    }
}

展平此可选检查的最佳方法是什么？我做了这样的东西，它不是可变参数，但我不太关心（membr3如果真的有必要，我可以再添加一个级别（用 重载），除此之外的一切都是糟糕的代码）。

template<typename T, typename M>
auto flatten_opt(const std::optional<T> opt, M membr){
    if (opt.has_value() && (opt.value().*membr).has_value()){
        return std::optional{*((*opt).*membr)};
    }
    return decltype(std::optional{*((*opt).*membr)}){};
}

template<typename T, typename M1, typename M2>
auto ret_val_helper(){
    // better code would use declval here since T might not be 
    // default constructible.
    T t;
    M1 m1;
    M2 m2;
    return ((t.*m1).value().*m2).value();
}

template<typename T, typename M1, typename M2>
std::optional<decltype(ret_val_helper<T, M1, M2>())> flatten_opt(const std::optional<T> opt, M1 membr1, M2 membr2){
    if (opt.has_value() && (opt.value().*membr1).has_value()){
        const auto& deref1 = *((*opt).*membr1);
        if ((deref1.*membr2).has_value()) {
            return std::optional{*(deref1.*membr2)};
        }
    }
    return {};
}

void PrintMiddleName2(const std::optional<Form> form){
    auto flat  = flatten_opt(form, &Form::person, &Person::middle_name);
    if (flat) {
        std::cout << *flat;
    }
    else {
        std::cout << "<none>"  << std::endl; 
    }
}

神箭

笔记：

• 我不想切换std::optional到一些更好的可选。
• 我不太关心性能，除非我返回一个指针，否则我必须复制（除非 arg 是临时的），因为std::optional它不支持引用。
• 我不关心flatten_has_value函数（尽管它很有用），因为如果有一种方法可以很好地展平嵌套的可选项，那么还有一种方法可以编写该函数。
• 我知道我的代码看起来有效，但它很丑陋，所以我想知道是否有更好的解决方案。

Answer 1

您正在寻找的操作称为 monadic绑定操作，有时会拼写and_then（就像在P0798和Rust 中一样）。

您正在使用一个optional<T>和一个函数T -> optional<U>并想要取回一个optional<U>. 在这种情况下，函数是一个指向数据成员的指针，但在这个意义上它确实表现得像一个函数。&Form::person取 aForm并返回 a optional<Person>。

您应该以一种与函数类型无关的方式编写它。事实上，它特别是一个指向成员数据的指针在这里并不重要，也许明天你会想要一个指向成员函数的指针，甚至是一个自由函数。所以那是：

template <typename T,
          typename F,
          typename R = std::remove_cvref_t<std::invoke_result_t<F, T>>,
          typename U = mp_first<R>>
    requires SpecializationOf<R, std::optional>
constexpr auto and_then(optional<T> o, F f) -> optional<U>
{
    if (o) {
        return std::invoke(f, *o);
    } else {
        return std::nullopt;
    }
}

这是多种函数声明中的一种，即使使用概念也很难用 C++ 编写。我将把它作为一个练习来正确地添加引用到那里。我选择专门把它写成-> optional<U>而不是-> R因为我认为对于可读性很重要，你可以看到它确实返回了某种optional.

现在，问题是我们如何将其链接到多个函数。Haskell>>=用于 monadic 绑定，但在具有错误关联的 C++ 中（o >>= f >>= g将f >>= g首先评估并需要括号）。因此，下一个最接近的运算符选择将是>>（这意味着 Haskell 中有些不同，但我们不是 Haskell，所以没关系）。或者你可以借用|Ranges的模型来实现这个。

所以我们要么在语法上以：

auto flat  = form >> &Form::person >> &Person::middle_name;

或者

auto flat = form | and_then(&Form::person)
                 | and_then(&Person::middle_name);

组合多个 monadic 绑定的另一种方法是 Haskell 拼写的操作，>=>称为 Kleisli 组合。在这种情况下，它接受一个函数T -> optional<U>和一个函数U -> optional<V>并产生一个函数T -> optional<V>。这是编写约束非常烦人的事情，所以我打算跳过它，它看起来像这样（使用 Haskell 运算符拼写）：

template <typename F, typename G>
constexpr auto operator>=>(F f, G g) {
    return [=]<typename T>(T t){
        using R1 = std::remove_cvref_t<std::invoke_result_t<F, T>>;
        static_assert(SpecializationOf<R1, std::optional>);
        using R2 = std:remove_cvref_t<std::invoke_result_t<G, mp_first<R1>>>;
        static_assert(SpecializationOf<R2, std::optional>);

        if (auto o = std::invoke(f, t)) {
            return std::invoke(g, *o);
        } else {
            // can't return nullopt here, have to specify the type
            return R2();
        }
    };
}

然后你可以写（或者至少你可以写>=>一个你可以使用的运算符）：

auto flat  = form | and_then(&Form::person >=> &Person::middle_name);

因为>=>现在的结果是一个接受 aForm并返回一个的函数optional<string>。

Answer 2

让我们看看扁平化函数的最佳形式是什么样的。在这种情况下，“最佳”是指最小的演示文稿。

即使在最佳情况下，在执行展平操作时，您也需要提供：

1. optional<T>要展平的对象。
2. 展平操作函数名称。
3. 在每个展平步骤中按顺序间接引用的名称列表。

您的代码非常接近最优。唯一的问题是“名称列表”中的每个名称都必须包含您在该级别访问的成员的类型名称，假设可以使用T.

C++ 没有比这更好的机制。如果要访问对象的成员，则必须提供该对象的类型。如果你想间接这样做，C++ 允许使用成员指针，但是获得这样的指针需要在提取成员时知道对象的类型。offsetof当您获得偏移量时，即使是体操也需要使用类型名称。

反射将允许更好的东西，因为您可以传递静态反射可用于从当前使用的类型中获取成员指针的编译时字符串。但是 C++20 没有这样的特性。

Answer 3

对于本质上是可链接操作的东西，您有很多辅助函数。C++ 有链的东西：操作符。所以我可能会（ab）operator*用于这个。

对于您的具体情况，您只需要

template<class class_t, class member_t>
std::optional<std::remove_cv_t<member_t>> operator*(
        const std::optional<class_t>& opt, 
        const std::optional<member_t> class_t::*member) 
{
    if (opt.has_value()) return opt.value().*member;
    else return {};
}

void PrintMiddleName2(const std::optional<Form> form){
    auto middle = form * &Form::person * &Person::middle_name;
    if (middle) {
        std::cout << *middle;
    }
    else {
        std::cout << "<none>"  << std::endl; 
    }
}

但实际上，您可能还需要非可选成员、getter 方法和任意转换的变体，我在此处列出了这些变体，尽管我不能 100% 确定它们都能正确编译。

//data member
template<class class_t, class member_t>
std::optional<std::remove_cv_t<member_t>> operator*(const std::optional<class_t>& opt, const std::optional<member_t> class_t::*member) {
    if (opt.has_value()) return opt.value().*member;
    else return {};
}
template<class class_t, class member_t>
std::optional<std::remove_cv_t<member_t>> operator*(const std::optional<class_t>& opt, const member_t class_t::*member) {
    if (opt.has_value()) return {opt.value().*member};
    else return {};
}

//member function
template<class class_t, class return_t>
std::optional<std::remove_cv_t<return_t>> operator*(const std::optional<class_t>& opt, std::optional<return_t>(class_t::*member)()) {
    if (opt.has_value()) return opt.value().*member();
    else return {};
}
template<class class_t, class return_t>
std::optional<std::remove_cv_t<return_t>> operator*(const std::optional<class_t>& opt, return_t(class_t::*member)()) {
    if (opt.has_value()) return {opt.value().*member()};
    else return {};
}

//arbitrary function
template<class class_t, class return_t, class arg_t>
std::optional<std::remove_cv_t<return_t>> operator*(const std::optional<class_t>& opt, std::optional<return_t>(*transform)(arg_t&&)) {
    if (opt.has_value()) return transform(opt.value());
    else return {};
}
template<class class_t, class return_t, class arg_t>
std::optional<std::remove_cv_t<return_t>> operator*(const std::optional<class_t>& opt, return_t(*transform)(arg_t&&)) {
    if (opt.has_value()) return {transform(opt.value())};
    else return {};
}

http://coliru.stacked-crooked.com/a/26aa7a62f38bbd89