result.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#pragma once
 
#ifndef MTCORE_RESULT_H
#define MTCORE_RESULT_H
 
#include "../core.hpp"
#include "../traits.hpp"
#include "optional.hpp"
#include <memory>
#include <ostream>
#include <variant>


namespace mtcore {
  template<typename Underlying>
  struct Error;

  template<typename T, typename ErrType>
  struct Result;

  template<typename Underlying>
  struct Error {
    using Type = Underlying;
    Underlying code;

    template<typename T>
    operator Result<T, Underlying>() const noexcept;

    bool operator==(const Error &o) const noexcept { return code == o.code; }
    bool operator!=(const Error &o) const noexcept { return code != o.code; }
  };

  template<typename ErrType>
  struct Result<void, ErrType> {
    using Err    = ErrType;
    using ErrVal = Error<Err>;
    std::variant<std::monostate, ErrVal> val;

    Result() : val(std::monostate{}) {}

    static Result from_error(ErrVal err) { return Result(err, 0); }

    static Result from_success() { return Result(); }

    bool operator==(const Result &other) const noexcept {
      if (std::holds_alternative<Err>(val) && std::holds_alternative<Err>(other.val)) {
        return std::get<Err>(val) == std::get<Err>(other.val);
      }
      else if (std::holds_alternative<Err>(val) || std::holds_alternative<Err>(other.val)) {
        return false;
      }
      return true;
    }
 
    bool operator!=(const Result &other) const noexcept { return !(*this == other); }

    [[nodiscard]] bool is_error() const noexcept { return std::holds_alternative<ErrVal>(val); }

    [[nodiscard]] bool is_success() const noexcept { return std::holds_alternative<std::monostate>(val); }

    [[nodiscard]] ErrVal error() const noexcept {
      ensure(is_error(), "CANNOT GET AN ERROR FROM A SUCCESSFUL RESUTL!");
      return std::get<ErrVal>(val);
    }
 
    Result to_void() const { return *this; }
 
    template<typename R>
    Result<R, Err> with_success_val(const R &s) {
      if (is_error()) {
        return error();
      }
      return s;
    }
 
  private:
    Result(ErrVal err, size_t) : val(err) {}
  };

  template<typename T, typename ErrType>
  struct Result {
    using Err    = ErrType;
    using ErrVal = Error<Err>;
    using Value  = T;
 
  private:
    std::variant<std::monostate, T, ErrVal> val;
 
  public:
    Result(const T &val) : val(val) {}

    Result(T &&val) : val(std::forward<T>(val)) {}

    static Result from_error(const ErrVal &err) { return Result(err, 0); }

    static Result from_success(const T &val) { return Result(val); }

    bool operator==(const Result &other) const noexcept {
      if (is_error()) {
        if (other.is_error()) {
          return error() == other.error();
        }
        return false;
      }
      if (other.is_error()) {
        return false;
      }
 
      if (is_success()) {
        if (other.is_success()) {
          return value() == other.value();
        }
        return false;
      }
      return false;
    }
 
    bool operator!=(const Result &other) const noexcept { return !(*this == other); }

    bool operator==(const T &other) const noexcept {
      if (is_error()) {
        return false;
      }
      return value() == other;
    }
 
    bool operator!=(const T &other) const noexcept { return !(*this == other); }

    [[nodiscard]] bool is_success() const noexcept { return std::holds_alternative<T>(val); }

    [[nodiscard]] T value() const noexcept {
      ensure(is_success(), "CANNOT GET VALUE WHEN ONE IS NOT PRESENT");
      return std::get<T>(val);
    }

    [[nodiscard]] bool is_error() const noexcept { return std::holds_alternative<ErrVal>(val); }

    [[nodiscard]] bool copy_if_present(std::remove_const_t<T> &out) const noexcept {
      if (is_success()) {
        out = value();
      }
      return is_success();
    }

    [[nodiscard]] bool move_if_present(T &out) noexcept {
      if (is_success()) {
        out = std::move(std::get<T>(val));
        val = std::monostate{};
        return true;
      }
      return is_success();
    }

    [[nodiscard]] ErrVal error() const noexcept {
      ensure(is_error(), "CANNOT GET AN ERROR FROM A SUCCESSFUL RESUTL!");
      return std::get<ErrVal>(val);
    }

    const T &operator*() const noexcept {
      ensure(is_success(), "CANNNOT DERERFERENCE ERROR RESULT");
      return std::get<T>(val);
    }

    T const *operator->() const noexcept {
      ensure(is_success(), "CANNNOT DERERFERENCE ERROR RESULT");
      return &std::get<T>(val);
    }

    T &operator*() {
      ensure(is_success(), "CANNNOT DERERFERENCE ERROR RESULT");
      return std::get<T>(val);
    }

    T *operator->() {
      ensure(is_success(), "CANNNOT DERERFERENCE ERROR RESULT");
      return &std::get<T>(val);
    }
 
    Result<void, Err> to_void() const {
      if (is_error()) {
        return this->error();
      }
      return {};
    }
 
    template<typename R>
    Result<R, Err> with_success_val(const R &s) {
      if (is_error()) {
        return error();
      }
      return s;
    }
 
  private:
    Result(const ErrVal &err, size_t) : val(err) {}
  };

  template<typename T>
  struct Success;

  template<>
  struct Success<void> {
    template<typename Err>
    operator Result<void, Err>() const noexcept;
  };

  template<typename T>
  struct Success {
    T val;
 
    template<typename Err>
    operator Result<T, Err>() const noexcept;
  };

  template<typename T>
  Success<T> success(const T &v) {
    return Success<T>{v};
  }

  inline Success<void> success() { return {}; }
 
  template<typename Err>
  Success<void>::operator Result<void, Err>() const noexcept {
    return Result<void, Err>::from_success();
  }
 
  template<typename Underlying>
  template<typename Err>
  Success<Underlying>::operator Result<Underlying, Err>() const noexcept {
    return Result<Underlying, Err>::from_success(val);
  }
 
  template<typename Underlying>
  template<typename T>
  Error<Underlying>::operator Result<T, Underlying>() const noexcept {
    return Result<T, Underlying>::from_error(*this);
  }

  template<typename Underlying>
  Error<Underlying> error(Underlying err) {
    return Error<Underlying>{err};
  }
}  // namespace mtcore
 
static_assert(mtcore::is_result_void<mtcore::Result<void, int>>);
static_assert(mtcore::is_result_with_value<mtcore::Result<int, int>, int>);

namespace mtcore::results {
  template<typename Success, typename Acc, typename F, Iterable I,
           typename Err = typename decltype(std::declval<F>()(
             std::declval<std::remove_const_t<typename decltype(std::declval<I>().iter())::IterElem>>()))::Err>
  Result<Success, Err> accumulate(Success initial, const Acc &acc, const F &func, const I &iterable) {
    auto iter  = iterable.iter();
    using Elem = std::remove_cv_t<typename decltype(iter)::IterElem>;
    Elem cur;
    while (iter.next().move_if_present(cur)) {
      auto res = func(cur);
      if (res.is_error()) {
        return res.error();
      }
      initial = acc(initial, res.value());
    }
    return success(initial);
  }

  template<typename F, Iterable I,
           typename Err = typename decltype(std::declval<F>()(
             std::declval<std::remove_const_t<typename decltype(std::declval<I>().iter())::IterElem>>()))::Err>
  Result<void, Err> foreach (const F &func, const I &iterable) {
    auto iter  = iterable.iter();
    using Elem = std::remove_cv_t<typename decltype(iter)::IterElem>;
    Elem cur;
    while (iter.next().move_if_present(cur)) {
      auto res = func(cur);
      if (res.is_error()) {
        return res.error();
      }
    }
    return success();
  }
 
  namespace impl {
    template<typename Err, typename F, typename... Args>
    struct Chain;
 
    template<typename V, typename T>
    struct TupleAppend;
 
    template<typename Out, typename Err, typename F, typename... Args>
    struct Map;
 
    template<typename F, typename Acc, typename... Args>
    struct Reduce;
 
    template<typename... Args>
    struct FirstVariadic;
 
    template<typename A, typename... Args>
    struct FirstVariadic<A, Args...> {
      using Type = A;
    };
 
    template<>
    struct FirstVariadic<> {
      using Type = void;
    };
  }  // namespace impl

  template<typename F, typename... Args,
           typename Err =
             typename decltype(std::declval<F>()(std::declval<typename impl::FirstVariadic<Args...>::Type>()))::Err>
  Result<void, Err> chain(const F &func, const Args &...args) {
    return impl::Chain<Err, F, Args...>::run(func, args...);
  }

  template<typename Success, typename Acc, typename F, typename... Args,
           typename Err =
             typename decltype(std::declval<F>()(std::declval<typename impl::FirstVariadic<Args...>::Type>()))::Err>
  Result<Success, Err> reduce(Success initVal, const Acc &acc, const F &func, const Args &...args) {
    return impl::Reduce<F, Acc, Args...>::template run<Success, Err>(initVal, func, acc, args...);
  }

  template<typename F, typename... Args,
           typename Out =
             typename decltype(std::declval<F>()(std::declval<typename impl::FirstVariadic<Args...>::Type>()))::Value,
           typename Err =
             typename decltype(std::declval<F>()(std::declval<typename impl::FirstVariadic<Args...>::Type>()))::Err>
  auto map(const F &func, const Args &...args) {
    return impl::Map<Out, Err, F, Args...>::run(func, args...);
  }
 
  namespace impl {
    template<typename V, typename... TA>
    struct TupleAppend<V, std::tuple<TA...>> {
      using Tuple = std::tuple<TA..., V>;
 
      static Tuple append(const V &v, const std::tuple<TA...> &tuple) {
        return append_impl(v, tuple, std::index_sequence_for<TA...>{});
      }
 
      template<size_t... Indx>
      static Tuple append_impl(const V &v, const std::tuple<TA...> &tuple, std::index_sequence<Indx...>) {
        return {std::get<Indx>(tuple)..., v};
      }
    };
 
    template<typename L, typename R>
    struct TupleConcat;
 
    template<typename... LA, typename... RA>
    struct TupleConcat<std::tuple<LA...>, std::tuple<RA...>> {
      using Tuple = std::tuple<LA..., RA...>;
    };
 
    template<typename Out, typename Err, typename F>
    struct Map<Out, Err, F> {
      using Tuple = std::tuple<>;
 
      static Result<std::tuple<>, Err> run(const F &) { return success(std::tuple{}); }
      template<typename T>
      static Result<T, Err> run_impl(const T &tuple, const F &) {
        return success(tuple);
      }
    };
 
    template<typename Out, typename Err, typename F, typename A, typename... Args>
    struct Map<Out, Err, F, A, Args...> {
      using Tuple = typename TupleAppend<Out, typename Map<Out, Err, F, Args...>::Tuple>::Tuple;
 
      template<typename... TA>
      static Result<typename TupleConcat<std::tuple<TA...>, Tuple>::Tuple, Err>
      run_impl(const std::tuple<TA...> &curTuple, const F &func, const A &arg, const Args &...args) {
        auto curRes = func(arg);
        if (curRes.is_error()) {
          return curRes.error();
        }
        auto newTuple = TupleAppend<Out, std::tuple<TA...>>::append(curRes.value(), curTuple);
        return Map<Out, Err, F, Args...>::run_impl(newTuple, func, args...);
      }
 
      static Result<Tuple, Err> run(const F &func, const A &arg, const Args &...args) {
        auto curRes = func(arg);
        if (curRes.is_error()) {
          return curRes.error();
        }
        return Map<Out, Err, F, Args...>::run_impl(std::tuple<Out>{curRes.value()}, func, args...);
      }
    };
 
    template<typename Err, typename F>
    struct Chain<Err, F> {
      static Result<void, Err> run(const F &) { return success(); }
    };
 
    template<typename Err, typename F, typename A, typename... Args>
    struct Chain<Err, F, A, Args...> {
      static Result<void, Err> run(const F &func, const A &arg, const Args &...args) {
        if (auto curRes = func(arg); curRes.is_error()) {
          return curRes.error();
        }
        return Chain<Err, F, Args...>::run(func, args...).to_void();
      }
    };
 
    template<typename F, typename Acc>
    struct Reduce<F, Acc> {
      template<typename Success, typename Err>
      static Result<Success, Err> run(Success curVal, const F &, const Acc &) {
        return success(curVal);
      }
    };
 
    template<typename F, typename Acc, typename A, typename... Args>
    struct Reduce<F, Acc, A, Args...> {
      template<typename Success, typename Err>
      static Result<Success, Err> run(Success curVal, const F &func, const Acc &accumulator, const A &arg,
                                      const Args &...args) {
        auto curRes = func(arg);
        if (curRes.is_error()) {
          return curRes.error();
        }
        curVal = accumulator(curVal, curRes.value());
        return Reduce<F, Acc, Args...>::template run<Success, Err>(curVal, func, accumulator, args...);
      }
    };
  }  // namespace impl
}  // namespace mtcore::results
 
#endif  // MTCORE_RESULT_H