composition and choice subsume compound

Author: patrickroberts

README.md

@@ -31,7 +31,7 @@ struct simply::iface<insertable, Self> {
 int main() {
   using namespace std::string_literals;
 
-  struct affordances : simply::conjunction<insertable, simply::destructible> {};
+  struct affordances : simply::composes<insertable, simply::destructible> {};
 
   std::vector<simply::dyn<affordances>> values;
   values.emplace_back("Hello, world!"s);
@@ -51,11 +51,17 @@ int main() {
 
 ### Features
 
-- `dyn` for type erasure of affordances
+- `dyn<Affordance, Storage, Dispatch>` for type erasure of affordances
 - Concepts:
   - `affordance<Affordance>`
+  - `fundamental_affordance<Affordance>`
+  - `compound_affordance<Affordance>`
+  - `composition_affordance<Affordance>`
+  - `choice_affordance<Affordance>`
   - `affords<T, Affordance>`
 - Predefined affordances for common use-cases:
+  - `composes<Affordances...>`
+  - `chooses<Affordances...>`
   - `destructible`
   - `move_constructible`
   - `copy_constructible`
@@ -69,8 +75,7 @@ int main() {
 
 ### Planned Features
 
-- `disjunction` to compose affordances as unions
-- `inplace_storage`
+- `inplace_storage<Size, Align>`
 - `shared_storage`
 - `copy_on_write_storage`
 - `invocable` affordance template

include/simply/concepts.hpp

@@ -51,12 +51,21 @@ concept derived_from_specialization_of = requires(Derived *derived) {
 template <typename T>
 concept compound_affordance =
     simply::affordance<T> and
-    simply::derived_from_specialization_of<T, simply::conjunction>;
+    std::derived_from<T, simply::compound_affordance_base>;
 
 template <typename T>
 concept fundamental_affordance =
-    simply::affordance<T> and
-    not simply::derived_from_specialization_of<T, simply::conjunction>;
+    simply::affordance<T> and not simply::compound_affordance<T>;
+
+template <typename T>
+concept composition_affordance =
+    simply::compound_affordance<T> and
+    simply::derived_from_specialization_of<T, simply::composes>;
+
+template <typename T>
+concept choice_affordance =
+    simply::compound_affordance<T> and
+    simply::derived_from_specialization_of<T, simply::chooses>;
 
 template <typename T>
 concept member_affordance =
@@ -86,88 +95,88 @@ concept fundamental_destroy_affordance =
 template <typename T, typename U>
 concept different_from = not std::same_as<T, U>;
 
-template <simply::compound_affordance Compound, typename T>
-inline constexpr bool enable_affordance_for<Compound, T> =
+template <simply::composition_affordance Composition, typename T>
+inline constexpr bool enable_affordance_for<Composition, T> =
     simply::enable_affordance_for<
-        simply::unique_fundamental_affordances_t<Compound>, T>;
+        simply::unique_fundamental_affordances_t<Composition>, T>;
 
 template <simply::fundamental_affordance... Fundamental, typename T>
 inline constexpr bool
-    enable_affordance_for<simply::conjunction<Fundamental...>, T> =
+    enable_affordance_for<simply::composes<Fundamental...>, T> =
         (... and simply::enable_affordance_for<Fundamental, T>);
 
-template <simply::compound_affordance T, typename Tag>
+template <simply::composition_affordance T, typename Tag>
 inline constexpr bool enable_affordance_tag<T, Tag> =
     simply::enable_affordance_tag<simply::unique_fundamental_affordances_t<T>,
                                   Tag>;
 
 template <simply::fundamental_affordance... Ts, typename Tag>
-inline constexpr bool enable_affordance_tag<simply::conjunction<Ts...>, Tag> =
+inline constexpr bool enable_affordance_tag<simply::composes<Ts...>, Tag> =
     (... or simply::enable_affordance_tag<Ts, Tag>);
 
-template <simply::compound_affordance Compound, typename Tag>
-struct fundamental_affordance_type<Compound, Tag>
+template <simply::composition_affordance Composition, typename Tag>
+struct fundamental_affordance_type<Composition, Tag>
     : simply::fundamental_affordance_type<
-          simply::unique_fundamental_affordances_t<Compound>, Tag> {};
+          simply::unique_fundamental_affordances_t<Composition>, Tag> {};
 
 template <simply::fundamental_affordance... Fundamental, typename Tag>
-struct fundamental_affordance_type<simply::conjunction<Fundamental...>, Tag>
+struct fundamental_affordance_type<simply::composes<Fundamental...>, Tag>
     : simply::fundamental_affordance_type<Fundamental, Tag>... {};
 
 template <simply::fundamental_affordance Affordance, typename Tag>
   requires simply::enable_affordance_tag<Affordance, Tag>
 struct fundamental_affordance_type<Affordance, Tag>
     : std::type_identity<Affordance> {};
 
-// terminate on outer affordances<>
+// terminate on outer composes<>
 template <typename Unique>
-struct unique_fundamental_affordances<simply::conjunction<>, Unique>
+struct unique_fundamental_affordances<simply::composes<>, Unique>
     : std::type_identity<Unique> {};
 
-// handle outer Fundamental as affordances<Fundamental>
+// handle outer Fundamental as composes<Fundamental>
 template <simply::fundamental_affordance Fundamental, typename Unique>
 struct unique_fundamental_affordances<Fundamental, Unique>
-    : simply::unique_fundamental_affordances<simply::conjunction<Fundamental>,
+    : simply::unique_fundamental_affordances<simply::composes<Fundamental>,
                                              Unique> {};
 
-// handle outer Compound as affordances<...>
-template <simply::compound_affordance Compound, typename Unique>
-struct unique_fundamental_affordances<Compound, Unique>
+// handle outer Composition as composes<...>
+template <simply::composition_affordance Composition, typename Unique>
+struct unique_fundamental_affordances<Composition, Unique>
     : simply::unique_fundamental_affordances<
-          simply::base_conjunction_t<Compound>, Unique> {};
+          simply::base_composition_t<Composition>, Unique> {};
 
 // add inner Fundamental if different from all Unique
 template <simply::fundamental_affordance Fundamental, typename... Rest,
           simply::different_from<Fundamental>... Unique>
-struct unique_fundamental_affordances<simply::conjunction<Fundamental, Rest...>,
-                                      simply::conjunction<Unique...>>
+struct unique_fundamental_affordances<simply::composes<Fundamental, Rest...>,
+                                      simply::composes<Unique...>>
     : simply::unique_fundamental_affordances<
-          simply::conjunction<Rest...>,
-          simply::conjunction<Unique..., Fundamental>> {};
+          simply::composes<Rest...>, simply::composes<Unique..., Fundamental>> {
+};
 
 // drop inner Fundamental otherwise
 template <simply::fundamental_affordance Fundamental, typename... Rest,
           typename Unique>
-struct unique_fundamental_affordances<simply::conjunction<Fundamental, Rest...>,
+struct unique_fundamental_affordances<simply::composes<Fundamental, Rest...>,
                                       Unique>
-    : simply::unique_fundamental_affordances<simply::conjunction<Rest...>,
+    : simply::unique_fundamental_affordances<simply::composes<Rest...>,
                                              Unique> {};
 
-// handle inner Compound as affordances<...>
-template <simply::compound_affordance Compound, typename... Rest,
+// handle inner Composition as composes<...>
+template <simply::composition_affordance Composition, typename... Rest,
           typename Unique>
-struct unique_fundamental_affordances<simply::conjunction<Compound, Rest...>,
+struct unique_fundamental_affordances<simply::composes<Composition, Rest...>,
                                       Unique>
     : simply::unique_fundamental_affordances<
-          simply::conjunction<simply::base_conjunction_t<Compound>, Rest...>,
+          simply::composes<simply::base_composition_t<Composition>, Rest...>,
           Unique> {};
 
-// handle inner affordances<First...> as First...
+// handle inner composes<First...> as First...
 template <typename... First, typename... Rest, typename Unique>
 struct unique_fundamental_affordances<
-    simply::conjunction<simply::conjunction<First...>, Rest...>, Unique>
+    simply::composes<simply::composes<First...>, Rest...>, Unique>
     : simply::unique_fundamental_affordances<
-          simply::conjunction<First..., Rest...>, Unique> {};
+          simply::composes<First..., Rest...>, Unique> {};
 
 } // namespace simply
 

include/simply/copyable.hpp

@@ -15,7 +15,7 @@ struct copy_constructible : simply::copy_affordance_base {
 };
 
 struct copyable
-    : simply::conjunction<simply::copy_constructible, simply::movable> {};
+    : simply::composes<simply::copy_constructible, simply::movable> {};
 
 } // namespace simply
 

include/simply/dyn.hpp

@@ -109,12 +109,14 @@ struct impl<Affordance, Dyn, R(Self, Args...) noexcept(NoExcept)> {
   }
 };
 
+// TODO refactor impl specializations below to not assume allocator_storage
 template <typename Dyn>
 concept _allocator_storage_dyn =
     simply::specialization_of<Dyn, simply::dyn> and
     simply::specialization_of<typename Dyn::storage_type,
                               simply::allocator_storage>;
 
+// TODO resolve storage type from choices by checking each compatibility with T
 template <typename T, typename Dyn>
 inline constexpr const auto &_storage_fn =
     simply::fn<typename Dyn::storage_type, T>;

include/simply/iface.hpp

@@ -8,13 +8,13 @@ namespace simply {
 template <simply::affordance Affordance, typename Self>
 struct iface {};
 
-template <simply::compound_affordance Affordance, typename Self>
+template <simply::composition_affordance Affordance, typename Self>
 struct iface<Affordance, Self>
     : simply::iface<simply::unique_fundamental_affordances_t<Affordance>,
                     Self> {};
 
 template <simply::fundamental_affordance... Affordances, typename Self>
-struct iface<simply::conjunction<Affordances...>, Self>
+struct iface<simply::composes<Affordances...>, Self>
     : simply::iface<Affordances, Self>... {};
 
 } // namespace simply

include/simply/movable.hpp

@@ -14,7 +14,7 @@ struct move_constructible : simply::move_affordance_base {
 };
 
 struct movable
-    : simply::conjunction<simply::move_constructible, simply::destructible> {};
+    : simply::composes<simply::move_constructible, simply::destructible> {};
 
 } // namespace simply
 

include/simply/type_traits.hpp

@@ -8,6 +8,8 @@ namespace simply {
 
 struct affordance_base {};
 
+struct compound_affordance_base : simply::affordance_base {};
+
 struct member_affordance_base : simply::affordance_base {};
 
 struct constructor_affordance_base : simply::member_affordance_base {};
@@ -48,7 +50,10 @@ using destroy_affordance_t =
                                           simply::destroy_affordance_base>;
 
 template <typename... Ts>
-struct conjunction : simply::affordance_base {};
+struct composes : simply::compound_affordance_base {};
+
+template <typename... Ts>
+struct chooses : simply::compound_affordance_base {};
 
 template <typename, template <typename...> typename>
 inline constexpr bool is_specialization_of_v = false;
@@ -64,21 +69,22 @@ using base_specialization_of_t = decltype(simply::_as_specialization_of<Base>(
     static_cast<Derived *>(nullptr)));
 
 template <typename T>
-using base_conjunction_t =
-    simply::base_specialization_of_t<T, simply::conjunction>;
+using base_composition_t =
+    simply::base_specialization_of_t<T, simply::composes>;
 
 template <typename T>
 inline constexpr bool enable_affordance =
     std::derived_from<T, simply::affordance_base>;
 
+// TODO integrate this customization point with impl and/or affordance_traits
 template <typename Affordance, typename T>
 inline constexpr bool enable_affordance_for =
     requires { &Affordance::template fn<T>; };
 
 template <typename T, typename Tag>
 inline constexpr bool enable_affordance_tag = std::derived_from<T, Tag>;
 
-template <typename Affordance, typename Unique = simply::conjunction<>>
+template <typename Affordance, typename Unique = simply::composes<>>
 struct unique_fundamental_affordances;
 
 template <typename Affordance>

include/simply/vtable.hpp

@@ -11,7 +11,7 @@ struct vtable
                      Self> {};
 
 template <simply::fundamental_affordance... Affordances, typename Self>
-struct vtable<simply::conjunction<Affordances...>, Self>
+struct vtable<simply::composes<Affordances...>, Self>
     : simply::vtable<Affordances, Self>... {};
 
 template <simply::fundamental_affordance Affordance, typename Self>
@@ -30,8 +30,8 @@ inline constexpr simply::vtable<Affordance, Self> vtable_for = {
 
 template <simply::fundamental_affordance... Affordances, typename Self,
           typename T>
-inline constexpr simply::vtable<simply::conjunction<Affordances...>, Self>
-    vtable_for<simply::conjunction<Affordances...>, Self, T> = {
+inline constexpr simply::vtable<simply::composes<Affordances...>, Self>
+    vtable_for<simply::composes<Affordances...>, Self, T> = {
         simply::vtable_for<Affordances, Self, T>...,
 };
 

tests/counters.cpp

@@ -59,11 +59,9 @@ struct simply::iface<labeled<LabelT>, Self> {
 
 // test dyn<countable> at compile-time
 static_assert([] {
-  // compose the affordances into a compound affordance
   struct countable
-      : simply::conjunction<copy_countable<int>, labeled<char>,
-                            simply::copy_constructible, simply::destructible> {
-  };
+      : simply::composes<copy_countable<int>, labeled<char>,
+                         simply::copy_constructible, simply::destructible> {};
 
   using dyn = simply::dyn<countable>;
   static_assert(requires {

tests/stream.cpp

@@ -9,8 +9,8 @@
 TEST(Stream, TypeErasedInsertion) {
   using namespace std::string_literals;
 
-  struct affordances : simply::conjunction<simply::insertable<std::ostream>,
-                                           simply::destructible> {};
+  struct affordances : simply::composes<simply::insertable<std::ostream>,
+                                        simply::destructible> {};
 
   std::vector<simply::dyn<affordances>> values;
   values.emplace_back("Hello, world!"s);