either.hpp

Go to the documentation of this file.

 
#pragma once
#include <functional> // std::invoke
#include <variant>
#include <mpc/control/holding.hpp>
#include <mpc/control/monad.hpp>
#include <mpc/prelude.hpp>
#include <mpc/utility/alternative_value_t.hpp>
#include <mpc/utility/single.hpp>
 
// clang-format off
 
namespace mpc {
  // either
  // https://hackage.haskell.org/package/base-4.15.0.0/docs/src/Data-Either.html#Either
 
  template <class T>
  using left_t = single<T, std::false_type>;
 
  template <class T>
  using right_t = single<T, std::true_type>;
 
  template <class T>
  constexpr left_t<std::unwrap_ref_decay_t<T>> make_left(T&& t) {
    return std::forward<T>(t);
  }
 
  template <class T>
  constexpr right_t<std::unwrap_ref_decay_t<T>> make_right(T&& t) {
    return std::forward<T>(t);
  }
 
  template <class T, class U>
  using either = std::variant<left_t<T>, right_t<U>>;
 
  namespace detail {
    template <class>
    struct is_either_impl : std::false_type {};
 
    template <class T, class U>
    struct is_either_impl<either<T, U>> : std::true_type {};
  } // namespace detail
 
  template <class T>
  concept is_either = detail::is_either_impl<std::remove_cvref_t<T>>::value;
 
  template <class T, class U>
  struct holding<either<T, U>> : std::type_identity<U> {};
 
  template <class T1, class T2>
  struct functor_traits<either<T1, T2>> {
    struct fmap_op {
      template <class F, is_either E>
      constexpr auto operator()(F&& f, E&& e) const
        -> either<alternative_value_t<0, E>,
                  std::unwrap_ref_decay_t<std::invoke_result_t<F, alternative_value_t<1, E>>>> {
        if (e.index() == 0) {
          return std::get<0>(std::forward<E>(e));
        } else {
          return make_right(std::invoke(std::forward<F>(f), *std::get<1>(std::forward<E>(e))));
        }
      }
    };
 
    static constexpr fmap_op fmap{};
    static constexpr auto replace2nd = functors::replace2nd;
  };
 
  template <class T1, class T2>
  struct monad_traits<either<T1, T2>> {
    struct bind_op {
      template <is_either E, class F>
      constexpr auto operator()(E&& e, F&& f) const //
        -> decltype(std::invoke(std::forward<F>(f), *std::get<1>(std::forward<E>(e)))) {
        if (e.index() == 0) {
          return std::get<0>(std::forward<E>(e));
        } else {
          return std::invoke(std::forward<F>(f), *std::get<1>(std::forward<E>(e)));
        }
      }
    };
 
    static constexpr bind_op bind{};
  };
 
  template <class T1, class T2>
  struct applicative_traits<either<T1, T2>> {
    struct pure_op {
      template <class U>
      constexpr auto operator()(U&& u) const        //
        -> either<T1, std::unwrap_ref_decay_t<U>> { //
        return make_right(std::forward<U>(u));
      }
    };
 
    struct seq_apply_op {
      template <is_either E1, is_either E2>
      constexpr auto operator()(E1&& e1, E2&& e2) const
        -> either<
          std::common_type_t<
            alternative_value_t<0, E1>,
            alternative_value_t<0, decltype(mpc::fmap(*std::get<1>(std::forward<E1>(e1)), std::forward<E2>(e2)))>
          >,
          alternative_value_t<1, decltype(mpc::fmap(*std::get<1>(std::forward<E1>(e1)), std::forward<E2>(e2)))>
        > {
        if (e1.index() == 0) {
          return std::get<0>(std::forward<E1>(e1));
        } else {
          return mpc::fmap(*std::get<1>(std::forward<E1>(e1)), std::forward<E2>(e2));
        }
      }
    };
 
    static constexpr pure_op pure{};
    static constexpr seq_apply_op seq_apply{};
    static constexpr auto liftA2 = applicatives::liftA2;
    static constexpr auto discard2nd = applicatives::discard2nd;
    static constexpr auto discard1st = monads::discard1st;
  };
} // namespace mpc
 
// clang-format on