A hierarchy of traits for the algebraic structures semigroup, monoid and group.
#include <algorithm>
#include <bit_factory/anyxx/v23/anys/ranges.hpp>
#include <catch2/catch_test_macros.hpp>
#include <print>
#include <string>
#include <vector>
namespace algebra {
TRAIT(equal_comparable, anyxx::dynamic_copyable,
(OP_FREE(bool, ==, eq, (anyxx::self const&), const),
OP_IMPL(public, bool, !=, ne, (anyxx::self const&), const,
(auto const& r) {
return !(as<equal_comparable>(self) ==
as<equal_comparable>(r));
})))
TRAIT(semigroup, equal_comparable,
(FN_PURE(anyxx::self, op, (anyxx::self const&), const)))
TRAIT_EX(monoid, semigroup, ,
(FN_STATIC_DEF((), anyxx::self, identity, (),
[]<typename M>(auto class_) {
return get_proxy_value(
class_.concat(std::ranges::empty_view<M>{}));
}),
FN_STATIC_DEF((), anyxx::self, concat,
((anyxx::any_self_forward_range const&)),
[]<typename M>(auto class_, const auto& r) {
auto id = class_.identity();
return get_proxy_value(std::ranges::fold_left(
r, id, [&](M const& m1, M const& m2) {
return m1.op(m2);
}));
})),
, , ())
TRAIT(group, monoid, (FN_PURE(anyxx::self, inverse, (), const)))
template <typename V>
struct semigroup_plus_trait_map : semigroup_default_trait_map<V> {
static auto op(V self, V r) {
std::println("op {}", typeid(V).name());
return self + r;
};
};
template <>
struct semigroup_trait_map<int> : semigroup_plus_trait_map<int> {};
template <>
struct monoid_trait_map<int> : monoid_default_trait_map<int> {
static auto concat(auto, auto const& r) {
using namespace anyxx;
std::println("concat {}", typeid(int).name());
return get_proxy_value(std::ranges::fold_left(
r, as<monoid>(0),
[&](trait_as<int, monoid> const& m1, trait_as<int, monoid> const& m2) {
return m1.op(m2);
}));
};
};
template <>
struct group_trait_map<int> : monoid_trait_map<int> {
static auto inverse(int self) { return -self; };
};
template <>
struct semigroup_trait_map<std::string>
: semigroup_plus_trait_map<std::string> {};
template <>
struct monoid_trait_map<std::string> : monoid_default_trait_map<std::string> {
static auto identity(auto) {
std::println("identy {}", typeid(std::string).name());
return std::string{};
};
};
}
namespace algebra_test {
using namespace algebra;
struct not_mappepd {};
static_assert(!is_semigroup_model<not_mappepd>);
template <anyxx::is_any Monoid>
void test_monoid(Monoid const& m, std::ranges::forward_range auto const& r) {
auto id = m.identity();
using type_1 = decltype(m.op(id.op(m)));
using type_2 = decltype(m.op(m.op(id)));
std::println("type_1: {}, type_2: {}", typeid(type_1).name(),
typeid(type_2).name());
static_assert(std::same_as<type_1, type_2>);
static_assert(std::same_as<type_1, Monoid>);
static_assert(std::same_as<type_2, Monoid>);
auto c1 = m.op(id).op(m) == m.op(m).op(id);
CHECK(c1);
auto c2 = m.concat(r) ==
std::ranges::fold_left(
r, m.identity(),
[&](Monoid const& m1, [[maybe_unused]] Monoid const& m2) {
return m1.op(m2);
});
CHECK(c2);
}
template <typename P1>
requires(!anyxx::is_any<P1>)
void test_monoid(P1 const& p1, std::ranges::forward_range auto const& r) {
using namespace anyxx;
static_assert(is_semigroup_model<P1>);
static_assert(is_monoid_model<P1>);
any_<using_<P1>, monoid> m{p1};
test_monoid(m, r);
}
template <class C>
concept can_call_op_on_class =
requires(anyxx::any_trait_class<C, monoid<>> class_,
anyxx::any_<anyxx::using_<C>, monoid> object_) {
{ class_.op(object_) };
};
template <class C>
concept can_call_op_on_object =
requires(anyxx::any_<anyxx::using_<C>, monoid> a,
anyxx::any_<anyxx::using_<C>, monoid> b) {
{ a.op(b) };
};
static_assert(!can_call_op_on_class<int>);
static_assert(can_call_op_on_object<int>);
}
TEST_CASE("algebra basics") {
using namespace anyxx;
using namespace algebra;
using namespace std::string_literals;
using int_monoid = any_<using_<int>, monoid>;
int_monoid x{2};
int_monoid y{x};
int_monoid z = y;
CHECK(get_proxy_value(z) == 2);
int_monoid a{std::move(x)};
CHECK(get_proxy_value(a) == 2);
static_assert(anyxx::is_proxy<decltype(x)::proxy_t>);
static_assert(anyxx::is_any<decltype(x)>);
static_assert(
anyxx::moveable_from<decltype(x)::proxy_t, decltype(y)::proxy_t>);
static_assert(
!anyxx::borrowable_from<decltype(x)::proxy_t, decltype(y)::proxy_t,
observeable_v_table>);
{
any_<using_<int>, monoid> im{999};
static_assert(is_proxy<trait_class<int>>);
static_assert(is_any<any_<trait_class<int>, monoid>>);
bool eq0 = im.identity() == as<monoid>(0);
CHECK(eq0);
auto x1 = im.concat(std::vector{as<monoid>(1), as<monoid>(2)});
auto y2 = as<monoid>(3);
CHECK(x1 == y2);
}
{
any_<using_<std::string>, monoid> sm{"XXX"};
auto i = sm.identity();
CHECK(sm.identity() == as<monoid>(""s));
auto x1 =
sm.concat(std::vector{as<monoid>("A"s), as<monoid>("B"s)});
auto y2 = as<monoid>("AB"s);
CHECK(x1 == y2);
}
}
TEST_CASE("algebra monoid") {
using namespace algebra;
using namespace algebra_test;
using namespace std::string_literals;
using namespace anyxx;
test_monoid((1), std::vector{2, 3});
test_monoid<any_<using_<int>, monoid>>(
as<monoid>(1), std::vector<any_<using_<int>, monoid>>{{2}, {3}});
test_monoid((1), std::vector<any_<using_<int>, monoid>>{{2}, {3}});
test_monoid<any_<using_<int>, monoid>>(as<monoid>(1), std::vector{2, 3});
test_monoid(("1"s), std::vector{"2"s, "3"s});
test_monoid<any_<using_<std::string>, monoid>>(
as<monoid>("1"s),
std::vector<any_<using_<std::string>, monoid>>{{"2"s}, {"3"s}});
}
namespace algebra_test {
using namespace algebra;
template <anyxx::is_any Group>
void test_group_traited(Group const& m,
std::ranges::forward_range auto const& r);
template <typename P1>
requires(!anyxx::is_any<P1>)
void test_group(P1 const& p1, std::ranges::forward_range auto const& r) {
static_assert(is_group_model<P1>);
using any_group = anyxx::any_<anyxx::using_<P1>, group>;
test_group_traited<any_group>(any_group{p1}, r);
}
template <anyxx::is_any Group>
void test_group(Group const& m, std::ranges::forward_range auto const& r) {
test_group_traited<Group>(m, r);
}
template <anyxx::is_any Group>
void test_group_traited(
Group const& g, [[maybe_unused]] std::ranges::forward_range auto const& r) {
using namespace anyxx;
auto id = g.identity();
static_assert(std::same_as<decltype(id), Group>);
auto inv = g.inverse();
static_assert(std::same_as<decltype(inv), Group>);
CHECK(g.op(inv) == id);
using type_1 = decltype(g.op(id.op(g)));
using type_2 = decltype(g.op(g.op(id)));
std::println("type_1: {}, type_2: {}", typeid(type_1).name(),
typeid(type_2).name());
static_assert(std::same_as<type_1, type_2>);
static_assert(std::same_as<type_1, Group>);
static_assert(std::same_as<type_2, Group>);
auto c1 = g.op(id).op(g) == g.op(g).op(id);
CHECK(c1);
auto g_concat = g.concat(r);
static_assert(
std::same_as<decltype(g_concat), anyxx::any_<anyxx::using_<int>, group>>);
auto c2 =
g_concat == std::ranges::fold_left(
r, g.identity(),
[&](Group const& g1, [[maybe_unused]] Group const& g2) {
return g1.op(g2);
});
CHECK(c2);
auto g_concat_inverse = g_concat.inverse();
auto g_identy = g_concat_inverse.op(g_concat);
CHECK(id == g_identy);
test_monoid(g, r);
}
}
TEST_CASE("algebra group") {
using namespace algebra;
using namespace anyxx;
using namespace algebra_test;
auto g = trait_class_<int, group<>>.identity();
static_assert(std::same_as<decltype(g), any_<using_<int>, group, void>>);
{
anyxx::any_<using_<int>, monoid> m1{0};
anyxx::any_<using_<int>, monoid> m2{std::move(m1)};
anyxx::any_<using_<int>, group> g1{0};
anyxx::any_<using_<int>, group> g2{std::move(g1)};
}
test_group((1), std::vector{2, 3});
test_group<any_<using_<int>, group>>(
as<group>(1), std::vector<any_<using_<int>, group>>{{2}, {3}});
}
namespace algebra_test {
struct int_mul {
int value = 0;
friend auto operator<=>(int_mul const&, int_mul const&) = default;
};
}
template <>
struct algebra::semigroup_trait_map<algebra_test::int_mul>
: algebra::semigroup_default_trait_map<algebra_test::int_mul> {
static auto op(algebra_test::int_mul self, algebra_test::int_mul r) {
using namespace anyxx;
std::println("op {}", typeid(algebra_test::int_mul).name());
return algebra_test::int_mul{self.value * r.value};
};
};
template <>
struct algebra::monoid_trait_map<algebra_test::int_mul>
: algebra::monoid_default_trait_map<algebra_test::int_mul> {
static auto identity(auto) {
std::println("identy {}", typeid(algebra_test::int_mul).name());
return algebra_test::int_mul{1};
};
};
TEST_CASE("algebra int_mul monoid") {
using namespace algebra;
using namespace anyxx;
using namespace algebra_test;
auto id = trait_class_<int_mul, monoid<>>.identity();
static_assert(std::same_as<decltype(id), any_<using_<int_mul>, monoid, void>>);
static_assert(!is_group_model<int_mul>);
test_monoid(int_mul{1}, std::vector{int_mul{2}, int_mul{3}});
}
C++ header only library for external polymorphism.