     }
 
     /// Resume the task awaiting the next iteration point by having it return
-    /// nil which signifies the end of the iteration.
-    ///
-    /// Calling this function more than once is idempotent; i.e. finishing more
-    /// than once does not alter the state beyond the requirements of
-    /// AsyncSequence; which claims that all values past a terminal state are
-    /// nil.
+    /// nil, which signifies the end of the iteration.
+    ///
+    /// Calling this function more than once has no effect. After calling
+    /// finish, the stream enters a terminal state and doesn't produces any additional
+    /// elements.
     public func finish() {
       storage.finish()
     }
 
-    /// A callback to invoke when iteration of a AsyncStream is cancelled.
-    ///
-    /// If an `onTermination` callback is set, when iteration of a AsyncStream is
-    /// cancelled via task cancellation that callback is invoked. The callback
-    /// is disposed of after any terminal state is reached.
-    ///
-    /// Cancelling an active iteration will first invoke the onTermination callback
-    /// and then resume yielding nil. This means that any cleanup state can be
-    /// emitted accordingly in the cancellation handler
+    /// A callback to invoke when canceling iteration of an asynchronous
+    /// stream.
+    ///
+    /// If an `onTermination` callback is set, using task cancellation to
+    /// terminate iteration of an `AsyncStream` results in a call to this
+    /// callback.
+    ///
+    /// Canceling an active iteration invokes the `onTermination` callback
+    /// first, then resumes by yielding `nil`. This means that you can perform
+    /// needed cleanup in the cancellation handler. After reaching a terminal
+    /// state as a result of cancellation, the `AsyncStream` sets the callback
+    /// to `nil`.
     public var onTermination: (@Sendable (Termination) -> Void)? {
       get {
         return storage.getOnTermination()

  }

  /// Resume the task awaiting the next iteration point by having it return
  /// normally from its suspension point or buffer the value if no awaiting
  /// next iteration is active where the `Element` is `Void`.
  ///
  /// This can be called more than once and returns to the caller immediately
  /// without blocking for any awaiting consumption from the iteration.
  /// without blocking for any awaiting consuption from the iteration.
  @discardableResult
  public func yield() -> YieldResult where Element == Void {
    return storage.yield(())

    build(Continuation(storage: storage))
  }

  /// Constructs an asynchronous stream from a given element-producing
  /// closure, with an optional closure to handle cancellation.
  ///
  /// - Parameters:
  ///   - produce: A closure that asynchronously produces elements for the
  ///     stream.
  ///   - onCancel: A closure to execute when canceling the stream's task.
  ///
  /// Use this convenience initializer when you have an asychronous function
  /// that can produce elements for the stream, and don't want to invoke
  /// a continuation manually. This initializer "unfolds" your closure into
  /// an asynchronous stream. The created stream handles conformance
  /// to the `AsyncSequence` protocol automatically, including termination
  /// (either by cancellation or by returning `nil` from the closure to finish
  /// iteration).
  ///
  /// The following example shows an `AsyncStream` created with this
  /// initializer that produces random numbers on a one-second interval. This
  /// example uses the Swift multiple trailing closure syntax, which omits
  /// the `unfolding` parameter label.
  ///
  ///     let stream = AsyncStream<Int> {
  ///             await Task.sleep(1 * 1_000_000_000)
  ///             return Int.random(in: 1...10)
  ///         }
  ///         onCancel: { @Sendable () in print ("Canceled.") }
  ///     )
  ///
  ///     // Call point:
  ///     for await random in stream {
  ///         print ("\(random)")
  ///     }
  ///
  ///
  public init(
    unfolding produce: @escaping () async -> Element?, 
    onCancel: (@Sendable () -> Void)? = nil
