core.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <concepts>
#include <type_traits>
#include <functional>
 
namespace kcenon::common {
namespace concepts {
 
template<typename T>
concept Resultable = requires(const T t) {
    { t.is_ok() } -> std::convertible_to<bool>;
    { t.is_err() } -> std::convertible_to<bool>;
};
 
template<typename T>
concept Unwrappable = requires(T t) {
    typename T::value_type;
    { t.unwrap() } -> std::same_as<typename std::add_lvalue_reference<
        typename std::add_const<typename T::value_type>::type>::type>;
    { t.unwrap_or(std::declval<typename T::value_type>()) }
        -> std::convertible_to<typename T::value_type>;
};
 
template<typename T>
concept Mappable = requires(const T t) {
    { t.map(std::declval<std::function<int(typename T::value_type)>>()) };
};
 
template<typename T>
concept Chainable = requires(const T t) {
    { t.and_then(std::declval<std::function<T(typename T::value_type)>>()) };
};
 
template<typename T>
concept MonadicResult = Resultable<T> && Mappable<T> && Chainable<T>;
 
template<typename T>
concept OptionalLike = requires(const T t) {
    { t.has_value() } -> std::convertible_to<bool>;
    { t.is_some() } -> std::convertible_to<bool>;
    { t.is_none() } -> std::convertible_to<bool>;
};
 
template<typename T>
concept ErrorInfo = requires(const T t) {
    { t.code } -> std::convertible_to<int>;
    { t.message } -> std::convertible_to<std::string>;
    { t.module } -> std::convertible_to<std::string>;
};
 
template<typename T>
concept ValueOrError = Resultable<T> && requires(const T t) {
    { t.value() };
    { t.error() };
};
 
} // namespace concepts
} // namespace kcenon::common