Rename Future into Async

rt/include/typon/core/future.hpp → rt/include/typon/core/async.hpp

-#ifndef TYPON_CORE_FUTURE_HPP_INCLUDED
-#define TYPON_CORE_FUTURE_HPP_INCLUDED
+#ifndef TYPON_CORE_ASYNC_HPP_INCLUDED
+#define TYPON_CORE_ASYNC_HPP_INCLUDED
 
 #include <coroutine>
 #include <memory>
@@ -15,7 +15,7 @@ namespace typon
 {
 
   template <typename T>
-  struct Future
+  struct Async
   {
     using value_type = T;
 
@@ -26,7 +26,7 @@ namespace typon
     };
 
     template <typename Promise>
-    Future(std::coroutine_handle<Promise> coroutine, bool ready)
+    Async(std::coroutine_handle<Promise> coroutine, bool ready)
     {
       if (ready)
       {
@@ -39,7 +39,7 @@ namespace typon
       }
     }
 
-    Future(Future && other) noexcept(std::is_nothrow_move_constructible_v<T>)
+    Async(Async && other) noexcept(std::is_nothrow_move_constructible_v<T>)
     {
       _result = other._result;
       if (!_result)
@@ -48,12 +48,12 @@ namespace typon
       }
     }
 
-    Future& operator=(Future && other)
+    Async& operator=(Async && other)
       noexcept(std::is_nothrow_move_constructible_v<T>)
     {
       if (this != &other)
       {
-        Future old { std::move(*this) };
+        Async old { std::move(*this) };
         _result = other._result;
         if (!_result)
         {
@@ -63,7 +63,7 @@ namespace typon
       return *this;
     }
 
-    ~Future()
+    ~Async()
     {
       if (!_result)
       {
@@ -84,7 +84,7 @@ namespace typon
 
   template <typename T>
     requires requires { sizeof(T); } && (sizeof(T) > 2 * sizeof(void*))
-  struct Future<T>
+  struct Async<T>
   {
     using value_type = T;
 
@@ -92,7 +92,7 @@ namespace typon
     std::coroutine_handle<> _coroutine;
 
     template <typename Promise>
-    Future(std::coroutine_handle<Promise> coroutine, bool ready)
+    Async(std::coroutine_handle<Promise> coroutine, bool ready)
     {
       _result = &(coroutine.promise());
       if (ready)
@@ -105,22 +105,22 @@ namespace typon
       }
     }
 
-    Future(const Future &) = delete;
-    Future& operator=(const Future &) = delete;
+    Async(const Async &) = delete;
+    Async& operator=(const Async &) = delete;
 
-    Future(Future && other) noexcept
+    Async(Async && other) noexcept
       : _result(other._result)
       , _coroutine(std::exchange(other._coroutine, nullptr))
     {}
 
-    Future& operator=(Future && other) noexcept
+    Async& operator=(Async && other) noexcept
     {
       std::swap(_coroutine, other._coroutine);
       std::swap(_result, other._result);
       return *this;
     }
 
-    ~Future()
+    ~Async()
     {
       if (_coroutine)
       {
@@ -137,7 +137,7 @@ namespace typon
 
   template <typename T>
     requires std::is_trivially_copyable_v<T>
-  struct Future<T>
+  struct Async<T>
   {
     using value_type = T;
 
@@ -148,7 +148,7 @@ namespace typon
     };
 
     template <typename Promise>
-    Future(std::coroutine_handle<Promise> coroutine, bool ready)
+    Async(std::coroutine_handle<Promise> coroutine, bool ready)
     {
       if (ready)
       {
@@ -161,10 +161,10 @@ namespace typon
       }
     }
 
-    Future(Future && other) = default;
-    Future& operator=(Future && other) = default;
+    Async(Async && other) = default;
+    Async& operator=(Async && other) = default;
 
-    ~Future()
+    ~Async()
     {
       if (!_result)
       {
@@ -184,7 +184,7 @@ namespace typon
 
 
   template <typename T>
-  struct Future<T&>
+  struct Async<T&>
   {
     using value_type = T&;
 
@@ -192,7 +192,7 @@ namespace typon
     T * _value;
 
     template <typename Promise>
-    Future(std::coroutine_handle<Promise> coroutine, bool ready)
+    Async(std::coroutine_handle<Promise> coroutine, bool ready)
     {
       if (ready)
       {
@@ -217,14 +217,14 @@ namespace typon
 
 
   template <>
-  struct Future<void>
+  struct Async<void>
   {
     using value_type = void;
 
     Result<void> * _result = nullptr;
 
     template <typename Promise>
-    Future(std::coroutine_handle<Promise> coroutine, bool ready)
+    Async(std::coroutine_handle<Promise> coroutine, bool ready)
     {
       if (ready)
       {
@@ -249,4 +249,4 @@ namespace typon
 }
 
 
-#endif // TYPON_FUTURE_HPP_INCLUDED
+#endif // TYPON_ASYNC_HPP_INCLUDED

rt/include/typon/core/fork.hpp

@@ -4,8 +4,8 @@
 #include <coroutine>
 #include <cstdint>
 
+#include <typon/core/async.hpp>
 #include <typon/core/continuation.hpp>
-#include <typon/core/future.hpp>
 #include <typon/core/result.hpp>
 #include <typon/core/scheduler.hpp>
 
@@ -102,7 +102,7 @@ namespace typon
         {
           continuation.children().insert(_coroutine);
         }
-        return Future<T>(_coroutine, !stolen);
+        return Async<T>(_coroutine, !stolen);
       }
     };
 

rt/include/typon/typon.hpp

@@ -3,8 +3,8 @@
 
 #include <utility>
 
+#include <typon/core/async.hpp>
 #include <typon/core/fork.hpp>
-#include <typon/core/future.hpp>
 #include <typon/core/join.hpp>
 #include <typon/core/root.hpp>
 #include <typon/core/task.hpp>