Rename all connection functions to their std counterparts:

- all_of -> when_all
- any_of -> when_any
- seq_of -> when_seq

doc/Index.md

@@ -16,9 +16,9 @@ This documentation covers the continuable library in detail
 
 - **Helper functions**
   - \link cti::make_continuable make_continuable\endlink - creates a cti::continuable_base from a callback tanking function.
-  - \link cti::all_of all_of\endlink - connects all given cti::continuable_base objects with an *all* logic.
-  - \link cti::any_of any_of\endlink - connects all given cti::continuable_base objects with an *any* logic.
-  - \link cti::seq_of seq_of\endlink - connects all given cti::continuable_base objects with a *sequence* logic.
+  - \link cti::when_all when_all\endlink - connects all given cti::continuable_base objects with an *all* logic.
+  - \link cti::when_any when_any\endlink - connects all given cti::continuable_base objects with an *any* logic.
+  - \link cti::when_seq when_seq\endlink - connects all given cti::continuable_base objects with a *sequence* logic.
 
 - **Class cti::continuable_trait** - A trait class for defining your own cti::continuable_base trait with the type-erasure backend of your choice.
   - \link cti::continuable_trait::callback callback\endlink - \copybrief cti::continuable_trait::callback

examples/documentation/example-documentation.cpp

@@ -129,9 +129,9 @@ void connecting_continuables() {
 
   // There are helper functions for connecting continuables:
   auto all =
-      cti::all_of(http_request("github.com"), http_request("travis-ci.org"));
+      cti::when_all(http_request("github.com"), http_request("travis-ci.org"));
   auto any =
-      cti::any_of(http_request("github.com"), http_request("travis-ci.org"));
+      cti::when_any(http_request("github.com"), http_request("travis-ci.org"));
 }
 
 int main() {

include/continuable/continuable-base.hpp

@@ -50,9 +50,9 @@
 /// cti::make_continuable() function which accepts a callback taking function.
 ///
 /// Also there are following support functions available:
-/// - cti::all_of() - connects cti::continuable_base's to an `all` connection.
-/// - cti::any_of() - connects cti::continuable_base's to an `any` connection.
-/// - cti::seq_of() - connects cti::continuable_base's to a sequence.
+/// - cti::when_all() - connects cti::continuable_base's to an `all` connection.
+/// - cti::when_any() - connects cti::continuable_base's to an `any` connection.
+/// - cti::when_seq() - connects cti::continuable_base's to a sequence.
 ///
 namespace cti {
 /// \cond false
@@ -1956,15 +1956,26 @@ auto make_continuable(Continuation&& continuation) {
 ///
 /// \see continuable_base::operator && for details.
 ///
-/// \since version 1.0.0
+/// \since version 1.1.0
 template <typename... Continuables>
-auto all_of(Continuables&&... continuables) {
+auto when_all(Continuables&&... continuables) {
   static_assert(sizeof...(continuables) >= 2,
                 "Requires at least 2 continuables!");
   return detail::util::fold(detail::util::and_folding(),
                             std::forward<Continuables>(continuables)...);
 }
 
+/// \copydoc when_all
+///
+/// \since version 1.0.0
+///
+/// \deprecated Use the `when_all` function instead.
+template <typename... Continuables>
+[[deprecated("Replaced by cti::when_all")]]
+auto all_of(Continuables&&... continuables) {
+  return when_all(std::forward<Continuables>(continuables)...);
+}
+
 /// Connects the given continuables with an *any* logic.
 ///
 /// \param continuables The continuable_base objects to connect.
@@ -1972,15 +1983,26 @@ auto all_of(Continuables&&... continuables) {
 ///
 /// \see continuable_base::operator|| for details.
 ///
-/// \since version 1.0.0
+/// \since version 1.1.0
 template <typename... Continuables>
-auto any_of(Continuables&&... continuables) {
+auto when_any(Continuables&&... continuables) {
   static_assert(sizeof...(continuables) >= 2,
                 "Requires at least 2 continuables!");
   return detail::util::fold(detail::util::or_folding(),
                             std::forward<Continuables>(continuables)...);
 }
 
+/// \copydoc when_any
+///
+/// \since version 1.0.0
+///
+/// \deprecated Use the `when_any` function instead.
+template <typename... Continuables>
+[[deprecated("Replaced by cti::when_any")]]
+auto any_of(Continuables&&... continuables) {
+  return when_any(std::forward<Continuables>(continuables)...);
+}
+
 /// Connects the given continuables with a *seq* logic.
 ///
 /// \param continuables The continuable_base objects to connect.
@@ -1988,15 +2010,26 @@ auto any_of(Continuables&&... continuables) {
 ///
 /// \see continuable_base::operator>> for details.
 ///
-/// \since version 1.0.0
+/// \since version 1.1.0
 template <typename... Continuables>
-auto seq_of(Continuables&&... continuables) {
+auto when_seq(Continuables&&... continuables) {
   static_assert(sizeof...(continuables) >= 2,
                 "Requires at least 2 continuables!");
   return detail::util::fold(detail::util::seq_folding(),
                             std::forward<Continuables>(continuables)...);
 }
 
+/// \copydoc when_seq
+///
+/// \since version 1.0.0
+///
+/// \deprecated Use the `when_seq` function instead.
+template <typename... Continuables>
+[[deprecated("Replaced by cti::when_seq")]]
+auto seq_of(Continuables&&... continuables) {
+  return when_seq(std::forward<Continuables>(continuables)...);
+}
+
 /// Trait to retrieve a continuable_base type with a given type-erasure backend.
 ///
 /// Every object may me used as type-erasure backend as long as the

test/unit-test/test-continuable-connection-all.cpp

@@ -41,7 +41,7 @@ TYPED_TEST(single_dimension_tests, is_logical_all_connectable) {
   }
 
   {
-    auto chain = cti::all_of(this->supply(1, 2), this->supply(3, 4));
+    auto chain = cti::when_all(this->supply(1, 2), this->supply(3, 4));
     EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4);
   }
 

test/unit-test/test-continuable-connection-any.cpp

@@ -41,7 +41,8 @@ TYPED_TEST(single_dimension_tests, is_logical_any_connectable) {
   }
 
   {
-    auto chain = cti::any_of(this->supply(1), this->supply(2), this->supply(3));
+    auto chain =
+        cti::when_any(this->supply(1), this->supply(2), this->supply(3));
     EXPECT_ASYNC_RESULT(std::move(chain), 1);
   }
 

test/unit-test/test-continuable-connection-seq.cpp

@@ -36,7 +36,7 @@ TYPED_TEST(single_dimension_tests, is_logical_seq_connectable) {
   }
 
   {
-    auto chain = cti::seq_of(this->supply(1), this->supply(2), this->supply(3));
+    auto chain = cti::when_seq(this->supply(1), this->supply(2), this->supply(3));
     EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3);
   }