// Current approach: abstract class with virtual methods
class IExecutor {
public:
    virtual ~IExecutor() = default;
    virtual void execute(std::function<void()> task) = 0;
    virtual void shutdown() = 0;
    virtual bool is_running() const = 0;
};

// Consumers must inherit and implement
class thread_pool_executor : public IExecutor {
    void execute(std::function<void()> task) override { /*...*/ }
    void shutdown() override { /*...*/ }
    bool is_running() const override { /*...*/ }
};

// Current: No constraints, cryptic errors if T doesn't have expected methods
template<typename T>
Result<T> map(std::function<T(U)> func);

// Current: Macros for conditional behavior
#define COMMON_RETURN_IF_ERROR(result) \
    if (!(result).is_ok()) return (result).error()

// include/kcenon/common/concepts/executor.h
namespace kcenon::common::concepts {

template<typename E>
concept Executor = requires(E executor, std::function<void()> task) {
    { executor.execute(task) } -> std::same_as<void>;
    { executor.shutdown() } -> std::same_as<void>;
    { executor.is_running() } -> std::convertible_to<bool>;
};

template<typename J>
concept Job = requires(J job) {
    { job.execute() } -> std::same_as<void>;
    { job.get_name() } -> std::convertible_to<std::string_view>;
    { job.get_priority() } -> std::convertible_to<int>;
};

template<typename L>
concept Logger = requires(L logger, std::string_view msg, log_level level) {
    { logger.log(level, msg) } -> std::same_as<void>;
    { logger.is_enabled(level) } -> std::convertible_to<bool>;
};

template<typename M>
concept MetricCollector = requires(M collector, std::string_view name, double value) {
    { collector.increment(name, value) } -> std::same_as<void>;
    { collector.gauge(name, value) } -> std::same_as<void>;
    { collector.histogram(name, value) } -> std::same_as<void>;
};

} // namespace kcenon::common::concepts

// include/kcenon/common/patterns/result.h
namespace kcenon::common {

template<typename T>
concept ResultValue = std::movable<T> || std::is_void_v<T>;

template<typename F, typename T>
concept ResultMapper = requires(F f, T value) {
    { std::invoke(f, std::move(value)) };
};

template<ResultValue T>
class Result {
public:
    template<ResultMapper<T> F>
    auto map(F&& func) -> Result<std::invoke_result_t<F, T>>;

    template<typename F>
        requires std::invocable<F, T> && 
                 std::same_as<std::invoke_result_t<F, T>, Result<typename std::invoke_result_t<F, T>::value_type>>
    auto and_then(F&& func);
};

} // namespace kcenon::common

// Type-safe logging that works with any Logger implementation
template<concepts::Logger L>
void log_error(L& logger, std::string_view message) {
    logger.log(log_level::error, message);
}

// Executor-agnostic task submission
template<concepts::Executor E>
void submit_task(E& executor, std::function<void()> task) {
    executor.execute(std::move(task));
}

// Both approaches work simultaneously
class IExecutor { /*...*/ };                    // Keep existing

template<typename E>
concept Executor = requires(E e) { /*...*/ };   // Add concept

// IExecutor implementations automatically satisfy Executor concept
static_assert(Executor<thread_pool_executor>);

// New APIs use concepts by default
template<Executor E>
class task_scheduler { /*...*/ };

// Existing APIs remain unchanged for compatibility
void legacy_function(IExecutor& executor);

// Mark abstract classes as deprecated
class [[deprecated("Use Executor concept instead")]] IExecutor { /*...*/ };