如何在C++编译期实现范畴论范畴？能否用C++20 Concepts？

完全可以用C模板和C20 Concepts实现编译期范畴，下面直接拆解实现思路和可运行的代码示例：

1. 定义范畴的核心Concepts #

范畴的本质是对象集合 + 态射集合，必须满足三个法则：态射复合封闭、复合满足结合律、每个对象存在单位态射。用C++20 Concepts可以严格约束这些行为：

#include <concepts>
#include <type_traits>
#include <utility>

// 约束态射类型：需支持复合操作，且关联源/目标对象类型
template<typename Morphism>
concept CategoryMorphism = requires(Morphism f, Morphism g) {
    { f * g } -> std::same_as<Morphism>; // 态射复合操作（用operator*表示，可自定义）
    typename Morphism::SourceObject;     // 关联源对象类型
    typename Morphism::TargetObject;     // 关联目标对象类型
};

// 约束范畴类型：需提供对象、态射类型，且满足范畴法则
template<typename Cat>
concept Category = requires {
    typename Cat::Object;                // 范畴的对象类型
    typename Cat::Morphism;              // 范畴的态射类型
    requires CategoryMorphism<typename Cat::Morphism>;
    { Cat::identity(std::declval<typename Cat::Object>()) } 
        -> std::same_as<typename Cat::Morphism>; // 获取单位态射的静态方法
};

2. 实现有限集合范畴FiniteSet #

有限集合的核心信息（元素类型、元素列表）都能在编译期确定，我们用模板类标记对象，用带constexpr函数的模板类封装态射：

2.1 定义有限集合对象 #

用模板类标记集合的元素类型，可通过WithElements嵌套模板定义具体的有限元素集合：

template<typename T>
struct FiniteSetObject {
    // 嵌套模板：绑定具体的有限元素列表（用std::integer_sequence存储编译期元素）
    template<T... Elems>
    using WithElements = FiniteSetObject<std::integer_sequence<T, Elems...>>;
};

2.2 定义有限集合态射 #

态射是从源集合到目标集合的编译期可计算函数，封装成模板类，支持复合操作：

template<typename SrcObj, typename TgtObj, auto Func>
struct FiniteSetMorphism {
    using SourceObject = SrcObj;
    using TargetObject = TgtObj;

    // 态射复合：g * f 表示先执行f，再执行g
    template<typename OtherMorphism>
    requires std::same_as<typename OtherMorphism::TargetObject, SrcObj>
    constexpr auto operator*(const OtherMorphism&) const {
        return FiniteSetMorphism<
            typename OtherMorphism::SourceObject,
            TgtObj,
            [](auto x) { return Func(OtherMorphism::apply(x)); }
        >{};
    }

    // 编译期应用态射到元素
    static constexpr auto apply(auto x) {
        return Func(x);
    }
};

2.3 封装FiniteSet范畴 #

整合对象和态射，提供单位态射（恒等函数）：

template<typename T>
struct FiniteSet {
    using Object = FiniteSetObject<T>;

    // 态射类型别名：绑定源对象、目标对象和具体函数
    template<typename Src, typename Tgt, auto Func>
    using Morphism = FiniteSetMorphism<Src, Tgt, Func>;

    // 生成单位态射：恒等映射
    static constexpr auto identity(const Object&) {
        return Morphism<Object, Object, [](auto x) { return x; }>{};
    }
};

// 编译期验证FiniteSet符合范畴约束
static_assert(Category<FiniteSet<int>>);

3. 编译期验证范畴法则 #

用static_assert直接在编译期验证单位元、结合律等范畴核心法则：

3.1 验证单位元法则 #

using IntSet = FiniteSet<int>::Object;
auto id = FiniteSet<int>::identity(IntSet{});
auto increment = FiniteSet<int>::Morphism<IntSet, IntSet, [](int x) { return x + 1; }>{};

// 左单位元：id * increment == increment
static_assert(std::is_same_v<decltype(id * increment), decltype(increment)>);
// 右单位元：increment * id == increment
static_assert(std::is_same_v<decltype(increment * id), decltype(increment)>);

3.2 验证结合律 #

auto double_val = FiniteSet<int>::Morphism<IntSet, IntSet, [](int x) { return x * 2; }>{};
auto decrement = FiniteSet<int>::Morphism<IntSet, IntSet, [](int x) { return x - 3; }>{};

// (decrement * double_val) * increment == decrement * (double_val * increment)
static_assert(std::is_same_v<decltype((decrement * double_val) * increment), decltype(decrement * (double_val * increment))>);

4. 定义具体的有限集合示例 #

通过WithElements定义带具体元素的有限集合，并验证态射的编译期计算：

// 定义具体有限集合：{1,2,3}
using IntSet123 = FiniteSetObject<int>::WithElements<1,2,3>;
// 定义目标集合：{2,4,6}
using IntSet246 = FiniteSetObject<int>::WithElements<2,4,6>;

// 定义态射：将{1,2,3}元素翻倍映射到{2,4,6}
auto double_morphism = FiniteSet<int>::Morphism<IntSet123, IntSet246, [](int x) { return x * 2; }>{};

// 编译期验证映射结果
static_assert(double_morphism.apply(1) == 2);
static_assert(double_morphism.apply(2) == 4);
static_assert(double_morphism.apply(3) == 6);

内容的提问来源于stack exchange，提问作者AmateurCategorist