monad.hpp

// Copyright (c) 2022, Tyler Weaver
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright
//      notice, this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
//
//    * Neither the name of the copyright holder nor the names of its
//      contributors may be used to endorse or promote products derived from
//      this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
 
#pragma once
 
#include <optional>
 
#include "fp/_external/expected.hpp"
 
namespace fp {
 
template <typename T>
constexpr std::optional<T> make_opt(T value) {
  return std::optional<T>{value};
}
 
template <typename T, typename F>
constexpr auto mbind(const std::optional<T>& opt, F f)
    -> decltype(f(opt.value())) {
  if (opt) {
    return f(opt.value());
  } else {
    return {};
  }
}
 
template <typename T, typename E, typename F,
          typename Ret = typename std::result_of<F(T)>::type>
constexpr Ret mbind(const tl::expected<T, E>& exp, F f) {
  if (exp) {
    return f(exp.value());
  }
  return tl::make_unexpected(exp.error());
}
 
template <typename F, typename Ret = typename std::result_of<F()>::type,
          typename Exp = tl::expected<Ret, std::exception_ptr>>
Exp mtry(F f) {
  try {
    return Exp{f()};
  } catch (...) {
    return tl::make_unexpected(std::current_exception());
  }
}
 
template <typename F, typename G>
constexpr auto mcompose(F f, G g) {
  return [=](auto value) { return mbind(f(value), g); };
}
 
template <typename T, typename G, typename... Types>
constexpr auto mcompose(T t, G g, Types... vars) {
  auto exp = mcompose(t, g);
  return mcompose(exp, vars...);
}
 
}  // namespace fp
 
template <typename T, typename F>
constexpr auto operator|(const std::optional<T>& opt, F f) {
  return fp::mbind(opt, f);
}
 
template <typename T, typename E, typename F,
          typename Ret = typename std::result_of<F(T)>::type>
constexpr Ret operator|(const tl::expected<T, E>& exp, F f) {
  return fp::mbind(exp, f);
}