Add documentation

Sources/Atoms/Atom/AsyncPhaseAtom.swift

@@ -1,14 +1,76 @@
+/// An atom that provides an ``AsyncPhase`` value from the asynchronous throwable function.
+///
+/// The value produced by the given asynchronous throwable function will be converted into
+/// an enum representation ``AsyncPhase`` that changes when the process is done or thrown an error.
+///
+/// ## Output Value
+///
+/// ``AsyncPhase``<Self.Success, Self.Failure>
+///
+/// ## Example
+///
+/// ```swift
+/// struct AsyncTextAtom: AsyncPhaseAtom, Hashable {
+///     func value(context: Context) async throws -> String {
+///         try await Task.sleep(nanoseconds: 1_000_000_000)
+///         return "Swift"
+///     }
+/// }
+///
+/// struct DelayedTitleView: View {
+///     @Watch(AsyncTextAtom())
+///     var text
+///
+///     var body: some View {
+///         switch text {
+///         case .success(let text):
+///             Text(text)
+///
+///         case .suspending:
+///             Text("Loading")
+///
+///         case .failure:
+///             Text("Failed")
+///     }
+/// }
+/// ```
+///
 public protocol AsyncPhaseAtom: AsyncAtom where Produced == AsyncPhase<Success, Failure> {
+    /// The type of success value that this atom produces.
     associatedtype Success
 
     #if compiler(>=6)
+        /// The type of errors that this atom produces.
         associatedtype Failure: Error
 
+        /// Asynchronously produces a value to be provided via this atom.
+        ///
+        /// Values provided or errors thrown by this method are converted to the unified enum
+        /// representation ``AsyncPhase``.
+        ///
+        /// - Parameter context: A context structure to read, watch, and otherwise
+        ///                      interact with other atoms.
+        ///
+        /// - Throws: The error that occurred during the process of creating the resulting value.
+        ///
+        /// - Returns: The process's result.
         @MainActor
         func value(context: Context) async throws(Failure) -> Success
     #else
+        /// The type of errors that this atom produces.
         typealias Failure = any Error
 
+        /// Asynchronously produces a value to be provided via this atom.
+        ///
+        /// Values provided or errors thrown by this method are converted to the unified enum
+        /// representation ``AsyncPhase``.
+        ///
+        /// - Parameter context: A context structure to read, watch, and otherwise
+        ///                      interact with other atoms.
+        ///
+        /// - Throws: The error that occurred during the process of creating the resulting value.
+        ///
+        /// - Returns: The process's result.
         @MainActor
         func value(context: Context) async throws -> Success
     #endif

Sources/Atoms/Atom/TaskAtom.swift

@@ -46,7 +46,7 @@ public protocol TaskAtom: AsyncAtom where Produced == Task<Success, Never> {
     /// - Parameter context: A context structure to read, watch, and otherwise
     ///                      interact with other atoms.
     ///
-    /// - Returns: A nonthrowing `Task` that produces asynchronous value.
+    /// - Returns: The process's result.
     @MainActor
     func value(context: Context) async -> Success
 }

Sources/Atoms/Atom/ThrowingTaskAtom.swift

@@ -50,7 +50,7 @@ public protocol ThrowingTaskAtom: AsyncAtom where Produced == Task<Success, any
     ///
     /// - Throws: The error that occurred during the process of creating the resulting value.
     ///
-    /// - Returns: A throwing `Task` that produces asynchronous value.
+    /// - Returns: The process's result.
     @MainActor
     func value(context: Context) async throws -> Success
 }