concepts.hpp

Go to the documentation of this file.

#pragma once
 
// ============================================================================
//  aria/concepts.hpp
// ----------------------------------------------------------------------------
//  Central catalogue of public-facing concepts used across the framework.
//
//  Per `docs/api-style.md` S-30, every templated public entry point should
//  prefer a named concept here over inline `requires` clauses. That way
//  IDEs and compilers can both surface a one-line "constraint not
//  satisfied" diagnostic instead of a multi-screen SFINAE explosion.
//
//  Concepts live in `aria::` so users never have to qualify them with
//  `aria::reactive::` or any other implementation namespace.
// ============================================================================
 
#include <concepts>
#include <functional>
#include <optional>
#include <type_traits>
 
namespace aria {
 
// ---------------------------------------------------------------------------
//  Equality / property-value primitives
// ---------------------------------------------------------------------------

template<typename T>
concept EqualityComparable = requires(const T& a, const T& b) {
    { a == b } -> std::convertible_to<bool>;
    { a != b } -> std::convertible_to<bool>;
};

template<typename F, typename Ret, typename... Args>
concept InvocableR = std::invocable<F, Args...>
                  && std::convertible_to<std::invoke_result_t<F, Args...>, Ret>;

template<typename T>
concept Observable = requires(T t) {
    typename T::value_type;
    { t.get() } -> std::convertible_to<typename T::value_type>;
};

template<typename T>
concept PropertyValue = std::copyable<T> && EqualityComparable<T>;
 
// ---------------------------------------------------------------------------
//  Read-only reactive sources
// ---------------------------------------------------------------------------

template<typename S>
concept ReadOnlyReactive =
    requires(S& s) {
        typename S::value_type;
        { s.get() } -> std::convertible_to<typename S::value_type>;
    } &&
    requires(S& s, std::function<void(const typename S::value_type&)> fn) {
        s.on_changed(std::move(fn));
    };

template<typename S, typename T>
concept ReadOnlyReactiveOf = ReadOnlyReactive<S>
                          && std::same_as<typename S::value_type, T>;
 
namespace detail {
 
template<typename T> struct is_optional                    : std::false_type {};
template<typename U> struct is_optional<std::optional<U>>   : std::true_type  {};
 
template<typename T>
inline constexpr bool is_optional_v = is_optional<T>::value;
 
}  // namespace detail

template<typename S>
concept ReadOnlyReactiveOptional = ReadOnlyReactive<S>
                                && detail::is_optional_v<typename S::value_type>;
 
// ---------------------------------------------------------------------------
//  Reactive graph participation
// ---------------------------------------------------------------------------
//
//  `aria::ReactiveNode<T>` (constraining types that play in the dependency
//  graph, i.e. inherit `aria::reactive::Node`) is defined alongside its
//  required complete type in `<aria/reactive/node.hpp>`. Including it
//  here would force every `<aria/concepts.hpp>` consumer to drag the
//  whole reactive subsystem; users that need `ReactiveNode` will already
//  be including `<aria/property.hpp>` (or similar) which transitively
//  pulls it in, so the concept is still surfaced from `aria::`.
 
}  // namespace aria