Стиль Haskell "Возможно" тип & * цепочка * в С++ 11

Ответ 1

Хорошее начало, но я думаю, что вы усердствовали в своем рвении, чтобы сделать ваш класс надежным. Лично я бы рекомендовал "хуже, лучше". Во-первых, повторите использование Boost.Optional:

struct nothing_type {
    template<typename T>
    operator boost::optional<T>() const
    { return {}; }
};
constexpr nothing_type nothing;

template<typename T>
boost::optional<T>
just(T&& t)
{
    return std::forward<T>(t);
}

template<typename Option, typename Functor>
auto maybe_do(Option&& option, Functor&& functor)
-> boost::optional<
    decltype( functor(*std::forward<Option>(option)) )
>
{
    // Forwarding 
    if(option)
        return functor(*std::forward<Option>(option));
    else
        return nothing;
}

Некоторые различные объяснения в отношении вещей, которые не очень важны:

• nothing не должен быть объектом, он все равно может быть функцией (возвращающей nothing_type), как вы делаете. Это не важно.

• Я старался сохранить ссылочную семантику just в соответствии с вашей версией. В качестве бонуса, однако, он все равно может иметь дело со значениями. Таким образом, с int i = 0; auto maybe = just(i); тогда тип maybe будет boost::optional<int&>, тогда как с auto maybe = just(42); это boost::optional<int>.

• *std::forward<Option>(option) может просто быть *option, поскольку Boost.Optional не поддерживает перенос, и не многие компиляторы поддерживают lvalue/rvalue *this (что необходимо для этого, чтобы оно имело значение). Мне просто нравятся шаблоны безупречной переадресации будущего.

• вы все равно можете называть maybe_do operator|. Однако я бы рекомендовал разместить его в пространстве имен и использовать using ns::operator| (или using namespace ns;), чтобы поместить его в область видимости. Вы можете дополнительно (или вместо этого) добавить проверку SFINAE (или написать несколько перегрузок), чтобы убедиться, что она участвует только в разрешении перегрузки в соответствующее время. Я рекомендую это избежать загрязнения пространства имен и досадных ошибок.

Важный материал:

Может показаться, что maybe_do сильно недооценен по сравнению с вашими перегрузками, которые могут иметь дело с указателями-членами. Но я бы рекомендовал сохранить его простым и вместо этого поставить нагрузку на клиентский код для адаптации указателей на элементы:

auto maybe = /* fetch an optional<T cv ref> from somewhere */
maybe_do(maybe, std::bind(&T::some_member, _1));

Аналогично клиентский код может использовать std::bind для частичной оценки бедного человека:

maybe_do(maybe, std::bind(some_functor, _1, "foo", _2, bar));

Ответ 2

Я был OP (потерял свою учетную запись при перенастройке SO). Вот последнее, что я придумал с помощью std:: invoke. Жизнь становится намного проще

template < typename T >
auto operator | (Maybe < T > const & v, auto && f)
{
    using U = std::decay_t < decltype(f(v.get())) >;
    if (v.isNull())
        return Maybe < U >::nothing();
    else
        return Maybe < U >::just(std::invoke(f, v.get()));
}

template < typename T >
auto operator | (Maybe < T > & v, auto && f)
{
    using U = std::decay_t < decltype(f(v.get())) >;
    if (v.isNull())
        return Maybe < U >::nothing();
    else
        return Maybe < U >::just(std::invoke(f, v.get()));
}

template < typename T >
auto operator | (Maybe < T > && v, auto && f)
{
    using U = std::decay_t < decltype(f(v.get())) >;
    if (v.isNull())
        return Maybe < U >::nothing();
    else
        return Maybe < U >::just(std::invoke(f, v.get()));
}

Ответ 3

Как восстанавливающий шаблон-aholic, я считаю своим долгом указать простое нешаблонное решение на основе исключения для данного примера.

Откорректируйте код, чтобы генерировать исключение вместо возврата Maybe/Optional, и код становится...

try
{
  print(getBalance(getCheckingAccount(getCustomer(customers, "12346"))));
}
catch(my_error_t) 
{}

Это не означает "Может быть"./Необязательные монады никогда не будут полезны в С++, но для многих случаев исключения будут делаться гораздо более идиоматично и легко понятны.

Ответ 4

Мои 5 cts.

Использование образца:

Maybe<string> m1 ("longlonglong");

auto res1 = m1 | lengthy  | length;

lengthy и length являются "монадическими лямбдами", то есть

auto length = [] (const string & s) -> Maybe<int>{ return Maybe<int> (s.length()); };

Полный код:

// g++ -std=c++1y answer.cpp

#include <iostream>
using namespace std;

// ..................................................
// begin LIBRARY
// ..................................................
template<typename T>
class Maybe {
  // 
  //  note: move semantics
  //  (boxed value is never duplicated)
  // 

private:

  bool is_nothing = false;

public:
  T value;

  using boxed_type = T;

  bool isNothing() const { return is_nothing; }

  explicit Maybe () : is_nothing(true) { } // create nothing

  // 
  //  naked values
  // 
  explicit Maybe (T && a) : value(std::move(a)), is_nothing(false) { }

  explicit Maybe (T & a) : value(std::move(a)), is_nothing(false) { }

  // 
  //  boxed values
  // 
  Maybe (Maybe & b) : value(std::move(b.value)), is_nothing(b.is_nothing) { b.is_nothing = true; }

  Maybe (Maybe && b) : value(std::move(b.value)), is_nothing(b.is_nothing) { b.is_nothing = true; }

  Maybe & operator = (Maybe & b) {
    value = std::move(b.value);
    (*this).is_nothing = b.is_nothing;
    b.is_nothing = true;
    return (*this);
  }
}; // class

// ..................................................
template<typename IT, typename F>
auto operator | (Maybe<IT> mi, F f)  // chaining (better with | to avoid parentheses)
{
  // deduce the type of the monad being returned ...
  IT aux;
  using OutMonadType = decltype( f(aux) );
  using OT = typename OutMonadType::boxed_type;

  // just to declare a nothing to return
  Maybe<OT> nothing;

  if (mi.isNothing()) {
    return nothing;
  }

  return f ( mi.value );
} // ()

// ..................................................
template<typename MO>
void showMonad (MO m) {
  if ( m.isNothing() ) {
    cout << " nothing " << endl;
  } else {
    cout << " something : ";
    cout << m.value << endl;
  }
}

// ..................................................
// end LIBRARY
// ..................................................

// ..................................................
int main () {

  auto lengthy = [] (const string & s) -> Maybe<string> { 
    string copyS = s;
    if  (s.length()>8) {
      return Maybe<string> (copyS);
    }
    return Maybe<string> (); // nothing
  };

  auto length = [] (const string & s) -> Maybe<int>{ return Maybe<int> (s.length()); };

  Maybe<string> m1 ("longlonglong");
  Maybe<string> m2 ("short");

  auto res1 = m1 | lengthy  | length;

  auto res2 = m2 | lengthy  | length;

  showMonad (res1);
  showMonad (res2);


} // ()

Ответ 5

Он был реализован на С++ 03 в течение длительного времени. Вы можете найти его в Boost как boost::optional. boost::optional предлагает простой интерфейс if (value).