Может ли функция быть применена к значению std :: option, возвращая факультативное значение?

Question

Может ли функция быть применена к значению std :: option, возвращая факультативное значение?

Я думаю, что применение функции к необязательному шаблону действительно полезно. Однако это сложно сделать с C ++ STL. Например:

std::optional<Vector3D> vec = tryCreateVector();
std::optional<float> length =
vec.has_value() ? std::optional<float>(vec->length()) : std::nullopt;

Есть ли эквивалент Хаскелла fmap или ржавчины Option::map в С ++? Что-то вроде следующего:

std::optional<Vector3D> vec = tryCreateVector();
std::optional<float> length = map(vec, [](auto vec) { return vec.length(); });

0

c++stdoptional stl

Решение

Другие решения

Насколько я знаю, стандартная библиотека не предоставляет такую функциональность из коробки. Это довольно легко реализовать, хотя.

#include <optional>
#include <iostream>
#include <functional>

std::optional<int> create_an_int()
{
return 1;
}

std::optional<int> dont_create_an_int()
{
return {};
}

template<typename T, typename F>
auto handler_wrapper(const std::optional<T>& in, F h)
{
return in.has_value() ? std::optional{h(*in)} : std::nullopt;
}

int main()
{
auto handler = [](const int& in){ return 3*in; };
auto test = create_an_int();
auto multiplied = handler_wrapper(test, handler);
std::cout << *multiplied << std::endl;
test = dont_create_an_int();
auto nulled = handler_wrapper(test, handler);
if (!nulled.has_value())
std::cout << "null optional" << std::endl;
}

По сути, все, что вам нужно сделать, — это создать шаблонную обертку, принимающую любые вызываемые и необязательные, и все готово (примечание: приведенный выше фрагмент не самая красивая / лучшая реализация, но, я думаю, должна дать вам хорошую отправную точку).
Код выше, очевидно, выдаст «3» и «необязательный ноль» в качестве вывода.

1

Источник

Accepted Answer

Вы можете определить следующую функцию:

namespace detail
{
template<typename Callable, typename T>
struct apply_helper
{
using T_noref = typename std::remove_reference<T>::type;
using value_type = typename T_noref::value_type;
using Callable_return = decltype(std::declval<Callable>()(std::declval<value_type>()));
using return_type = optional<Callable_return>;

static return_type eval(Callable&& f, T&& val)
{
if(val)
{
return apply(std::forward<Callable&&>(f), *val);
}
else return boost::none;
}

private:
static Callable_return apply(Callable&& f, value_type& v)
{
return f(v);
}
static Callable_return apply(Callable&& f, value_type const& v)
{
return f(v);
}
static Callable_return apply(Callable&& f, value_type&& v)
{
return f(v);
}

};
}
template<typename Callable, typename T>
optional<decltype(std::declval<Callable>()(std::declval<T>()))> apply(Callable&& f, optional<T> const& a)
{
return detail::apply_helper<Callable, optional<T> const&>::eval(std::forward<Callable>(f), a);
}

который затем может быть использован как:

optional<int> foo(optional<int> value)
{
auto f = [](int v){return v + 10;};
return apply(f, value);
}

1