Include what you use.

3 files changed, 24 insertions, 24 deletions

diff --git a/aisa/aisa.h b/aisa/aisa.h
index c9a215c..3c260c1 100644
--- a/aisa/aisa.h
+++ b/aisa/aisa.h
@@ -1,15 +1,10 @@
 #pragma once
 
-#include <coroutine>
 #include <cstdint>
-#include <initializer_list>
-#include <iostream>
 #include <optional>
 #include <utility>
 #include <vector>
 
-#include "aisa/coroutine.h"
-
 namespace aisa {
 
     using regnum_t = std::uint_fast64_t;
diff --git a/aisa/coroutine.h b/aisa/coroutine.h
index a456c89..333cb26 100644
--- a/aisa/coroutine.h
+++ b/aisa/coroutine.h
@@ -1,46 +1,47 @@
 #pragma once
 
 #include <coroutine>
+#include <optional>
 
 namespace aisa {
 
-    template<typename result_t> struct promise;
+    template<typename result_t> struct task_promise;
 
-    template<typename result_t> struct task : public std::coroutine_handle<promise<result_t>> {
-        using handle = std::coroutine_handle<struct promise<result_t>>;
-        using promise_type = struct promise<result_t>;
+    template<typename result_t> struct task : public std::coroutine_handle<task_promise<result_t>> {
+        using handle = std::coroutine_handle<task_promise<result_t>>;
+        using promise_type = task_promise<result_t>;
         bool await_ready() const noexcept { return handle::done(); }
         result_t await_resume() const noexcept;
-        template<typename other_t> void await_suspend(std::coroutine_handle<struct promise<other_t>> h) const noexcept;
+        template<typename other_t> void await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept;
         std::optional<result_t> operator()() noexcept;
     };
 
-    template<> struct task<void> : public std::coroutine_handle<promise<void>> {
-        using handle = std::coroutine_handle<struct promise<void>>;
-        using promise_type = struct promise<void>;
+    template<> struct task<void> : public std::coroutine_handle<task_promise<void>> {
+        using handle = std::coroutine_handle<task_promise<void>>;
+        using promise_type = task_promise<void>;
         bool await_ready() const noexcept { return handle::done(); }
         void await_resume() const noexcept;
-        template<typename other_t> void await_suspend(std::coroutine_handle<struct promise<other_t>> h) const noexcept;
+        template<typename other_t> void await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept;
         bool operator()() noexcept;
     };
 
-    template<typename result_t> struct promise {
+    template<typename result_t> struct task_promise {
         std::coroutine_handle<> precursor;
         std::optional<result_t> result;
-        promise() = default;
-        promise(const promise &) = delete;
-        task<result_t> get_return_object() noexcept { return task<result_t>{std::coroutine_handle<promise<result_t>>::from_promise(*this)}; }
+        task_promise() = default;
+        task_promise(const task_promise &) = delete;
+        task<result_t> get_return_object() noexcept { return task<result_t>{std::coroutine_handle<task_promise<result_t>>::from_promise(*this)}; }
         std::suspend_never initial_suspend() const noexcept { return {}; }
         std::suspend_always final_suspend() const noexcept { return {}; }
         void unhandled_exception() { }
         void return_value(result_t x) noexcept { result = std::move(x); }
     };
 
-    template<> struct promise<void> {
+    template<> struct task_promise<void> {
         std::coroutine_handle<> precursor;
-        promise() = default;
-        promise(const promise &) = delete;
-        task<void> get_return_object() noexcept { return task<void>{std::coroutine_handle<promise<void>>::from_promise(*this)}; }
+        task_promise() = default;
+        task_promise(const task_promise &) = delete;
+        task<void> get_return_object() noexcept { return task<void>{std::coroutine_handle<task_promise<void>>::from_promise(*this)}; }
         std::suspend_never initial_suspend() const noexcept { return {}; }
         std::suspend_always final_suspend() const noexcept { return {}; }
         void unhandled_exception() { }
@@ -54,7 +55,7 @@ namespace aisa {
         return std::move(x);
     }
 
-    template<typename result_t> template<typename other_t> void task<result_t>::await_suspend(std::coroutine_handle<struct promise<other_t>> h) const noexcept
+    template<typename result_t> template<typename other_t> void task<result_t>::await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept
     {
         h.promise().precursor = *this;
     }
@@ -87,7 +88,7 @@ namespace aisa {
         handle::destroy();
     }
 
-    template<typename other_t> void task<void>::await_suspend(std::coroutine_handle<struct promise<other_t>> h) const noexcept
+    template<typename other_t> void task<void>::await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept
     {
         h.promise().precursor = *this;
     }
diff --git a/aisa/eval.h b/aisa/eval.h
index 6d65520..30dc617 100644
--- a/aisa/eval.h
+++ b/aisa/eval.h
@@ -1,8 +1,12 @@
 #pragma once
 
 #include <coroutine>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include "aisa/aisa.h"
+#include "aisa/coroutine.h" // IWYU pragma: export
 
 namespace aisa {