Any++
Loading...
Searching...
No Matches
Examples for C++23
Introduction to Internal and External Polymorphism:
Using cref:
Using shared:
Using val:
Using shared and weak:
Using any pure:
any function:
any view:
trait_as:
downcast:
crosscast:
Case Study: factory and crosscast:
No Visitors! Open Dispatch:
using namespace anyxx;
TRAIT_EX(node, anyxx::deleteable, , , ,
(HAS_OPEN_DISPATCH), ())
struct Plus {
any<node> left_, right_;
};
struct Times {
any<node> left_, right_;
};
struct Integer {
int i;
};
// =============================================================================
// add behavior to existing classes, without changing them
//-----------------------------------------------------------------------------
// open dispatch evaluate, returns int, dispatched via an any<node>;
dispatch<int(virtual_<any<node>>)> evaluate;
auto __ = evaluate.define<Plus>([](auto const& expr) {
return evaluate(expr.left_) + evaluate(expr.right_);
});
auto __ = evaluate.define<Times>([](auto const& expr) {
return evaluate(expr.left_) * evaluate(expr.right_);
});
auto __ = evaluate.define<Integer>([](auto const& expr) { return expr.i; });
//
//-----------------------------------------------------------------------------
// render as Forth
dispatch<std::string(virtual_<any<node>>)> as_forth;
auto __ = as_forth.define<Plus>([](auto const& expr) {
return as_forth(expr.left_) + " " + as_forth(expr.right_) + " +";
});
auto __ = as_forth.define<Times>([](auto const& expr) {
return as_forth(expr.left_) + " " + as_forth(expr.right_) + " *";
});
auto __ = as_forth.define<Integer>(
[](auto const& expr) { return std::to_string(expr.i); });
//
Open Multi Dispatch for Spaceship Operator
TRAIT_EX(thing, anyxx::dynamic_copyable,
(FN(std::string, registry, (), const)), , ,
(HAS_OPEN_DISPATCH), ())
dispatch<any<thing>(virtual_<any<thing>>, virtual_<any<thing>>)> collide;
any<thing> operator<=>(any<thing> const& l, any<thing> const& r) {
return collide(l, r);
}
any<thing> run(std::vector<any<thing>> things) {
return *std::ranges::fold_left_first(
things, [](any<thing> const& winner, any<thing> const& next) {
std::print("{} <=> {} -> ", winner.registry(), next.registry());
auto result = winner <=> next;
std::println("{}!", result.registry());
return result;
});
}
Open Variant Dispatch: vany
Vany Multi Dispatch: Fancy Expression Tree
TRAIT_EX(evaluable, copyable,
(FN_IMPL(public, std::string, to_string, (), const,
(){ return std::format("{}", self); })),
, , (HAS_OPEN_DISPATCH), ())
using value = vany<evaluable, bool, int, double>;
using bool_int_double = vany_type_trait<value>::concrete_variant;
static_assert(std::is_same_v<bool_int_double, std::variant<bool, int, double>>);
TRAIT_EX(node, anyxx::deleteable,
(FN(value, evaluate, (), const))
, , , (HAS_OPEN_DISPATCH), ())
VANY_DISPACH_DECLARE(
, evaluate_plus,
(value(virtual_<any<evaluable>>, virtual_<any<evaluable>>)),
([]<no_any L, no_any R>(L&& l, R&& r) -> value
{ return std::forward<L>(l) + std::forward<R>(r); }));
struct plus {
any<node> left_, right_;
value evaluate() const {
return evaluate_plus(left_.evaluate(), right_.evaluate());
}
};
TRAIT_MAP(evaluable, std::string) {
std::string as_string(std::string const& self) { return self; };
};
auto __ = evaluate_plus.define<std::string, std::string>(
[](const auto& lhs, const auto& rhs) -> value { return lhs + rhs; });
auto __ = evaluate_plus.define<bool_int_double, std::string>(
[](const auto& lhs, const auto& rhs) -> value {
return as<evaluable>(lhs).to_string() + rhs;
});
auto __ = evaluate_plus.define<std::string, bool_int_double>(
[](const auto& lhs, const auto& rhs) -> value {
return lhs + as<evaluable>(rhs).to_string();
});