Either.hpp

Go to the documentation of this file.

#pragma once
#include <expected>
#include <stdexcept>
#include <functional>
 
#include <fishnet/FunctionalConcepts.hpp>
 
namespace fishnet{
 
template<typename T, typename E>
class Either: public std::expected<T,E>{
public:
    template<typename... Args>
    Either(Args&&... args): std::expected<T,E>(std::forward<Args>(args)...){}
 
    const T& value_or_throw() const&  {
        if(this->has_value())
            return this->value();
        if constexpr(std::convertible_to<E,std::string_view>){
            throw std::runtime_error(this->error());
        }else {
            throw std::runtime_error("No value present!");
        }
    }
 
    T& value_or_throw() &  {
        if(this->has_value())
            return this->value();
        if constexpr(std::convertible_to<E,std::string_view>){
            throw std::runtime_error(this->error());
        }else {
            throw std::runtime_error("No value present!");
        }
    }  
 
    T&& value_or_throw() &&  {
        if(this->has_value())
            return std::move(this->value());
        if constexpr(std::convertible_to<E,std::string_view>){
            throw std::runtime_error(this->error());
        }else {
            throw std::runtime_error("No value present!");
        }
    }
 
    const T& value_or_throw(const std::string & errorMsg) const&  {
        if(this->has_value())
            return this->value();
        else throw std::runtime_error(errorMsg);
    }   
 
    T& value_or_throw(const std::string & errorMsg) &  {
        if(this->has_value())
            return this->value();
        else throw std::runtime_error(errorMsg);
    }
 
    T&& value_or_throw(const std::string & errorMsg) &&  {
        if(this->has_value())
            return std::move(this->value());
        else throw std::runtime_error(errorMsg);
    }
 
    template<typename F> requires fishnet::util::UnaryFunction<F,T,Either<typename std::remove_cvref_t<std::invoke_result_t<F,T>>::value_type,E>>
    Either<typename std::remove_cvref_t<std::invoke_result_t<F,T>>::value_type,E> and_then(F&& f) & {
        using U = typename std::remove_cvref_t<std::invoke_result_t<F, const T&>>::value_type;
        if(this->has_value())
            return std::invoke(std::forward<F>(f), this->value());
        return Either<U,E>(std::unexpected(this->error()));
    }
 
    template<typename F> requires fishnet::util::UnaryFunction<F,T,Either<typename std::remove_cvref_t<std::invoke_result_t<F,T>>::value_type,E>>
    Either<typename std::remove_cvref_t<std::invoke_result_t<F,T>>::value_type,E> and_then(F&& f) && {
        using U = typename std::remove_cvref_t<std::invoke_result_t<F, T>>::value_type;
        if(this->has_value())
            return std::invoke(std::forward<F>(f), std::move(this->value()));
        return Either<U,E>(std::unexpected(this->error()));
    }
 
    template<typename F> requires fishnet::util::UnaryFunction<F,T, typename std::remove_cvref_t<std::invoke_result_t<F,T>>>
    Either<typename std::remove_cvref_t<std::invoke_result_t<F,T>>,E> transform(F&& f) & {
        using U = typename std::remove_cvref_t<std::invoke_result_t<F, const T&>>;
        if(this->has_value())
            return std::invoke(std::forward<F>(f), this->value());
        return Either<U,E>(std::unexpected(this->error()));
    }
 
    template<typename F> requires fishnet::util::UnaryFunction<F,T, typename std::remove_cvref_t<std::invoke_result_t<F,T>>>
    Either<typename std::remove_cvref_t<std::invoke_result_t<F,T>>,E> transform(F&& f) && { 
        using U = typename std::remove_cvref_t<std::invoke_result_t<F, T>>;
        if(this->has_value())
            return std::invoke(std::forward<F>(f), std::move(this->value()));
        return Either<U,E>(std::unexpected(this->error()));
    }
 
    template<typename F> requires std::convertible_to<std::invoke_result_t<F>,Either<T,E>>
    Either<T,E> or_else(F&& f) & {
        if(this->has_value())
            return *this;
        return Either<T,E>(std::invoke(std::forward<F>(f)));
    }
 
    template<typename F> requires std::convertible_to<std::invoke_result_t<F>,Either<T,E>>
    Either<T,E> or_else(F&& f) && {
        if(this->has_value())
            return std::move(*this);
        return Either<T,E>(std::invoke(std::forward<F>(f)));
    }
 
    void if_value(fishnet::util::Consumer<T> auto const & consumer){
        if(this->has_value())
            consumer(std::forward<T>(this->value()));
    }
 
    void if_value_or_error(fishnet::util::Consumer<T> auto const & consumer, fishnet::util::Consumer<E> auto const & errorConsumer){
        if(this->has_value())
            consumer(std::forward<T>(this->value()));
        else
            errorConsumer(std::forward<E>(this->error()));
    }
};
}