Revision: Remove ~Copyable from LambdaResponseStreamWriter and LambdaResponseWriter

Remove `~Copyable` from `LambdaResponseStreamWriter` and `LambdaResponseWriter`. Instead throw an error when `finish()` is called multiple times or when `write`/`writeAndFinish` is called after `finish()`.

Author: aryan-25

Sources/AWSLambdaRuntimeCore/Documentation.docc/Proposals/0001-v2-api.md

@@ -20,6 +20,9 @@ Versions:
       `LambdaWithBackgroundProcessingHandler`.
     - Update `LambdaCodableAdapter` to now be generic over any handler conforming to
       `LambdaWithBackgroundProcessingHandler` instead of `LambdaHandler`.
+- v1.2:
+  - Remove `~Copyable` from `LambdaResponseStreamWriter` and `LambdaResponseWriter`. Instead throw an error when
+    `finish()` is called multiple times or when `write`/`writeAndFinish` is called after `finish()`.
 
 ## Motivation
 
@@ -144,8 +147,8 @@ of the `EventLoop` family of interfaces.
 - This allows the lifecycle of the `LambdaRuntime` to be managed with `swift-service-lifecycle` _alongside_ and in the
   same way the lifecycles of the required services are managed, e.g.
   `try await ServiceGroup(services: [postgresClient, ..., lambdaRuntime], ...).run()`.
-- Dependencies can now be injected into `LambdaRuntime` — `swift-service-lifecycle` guarantees that the services will be
-  initialized _before_ the `LambdaRuntime`'s `run()` function is called.
+- Dependencies can now be injected into `LambdaRuntime`. With `swift-service-lifecycle`, services will be initialized
+  together with `LambdaRuntime`.
 - The required services can then be used within the handler in a structured concurrency manner.
   `swift-service-lifecycle` takes care of listening for termination signals and terminating the services as well as the
   `LambdaRuntime` in correct order.
@@ -196,22 +199,20 @@ below), which is the new base protocol for the `LambdaRuntime` (defined below as
 
 ```swift
 /// A writer object to write the Lambda response stream into
-public protocol LambdaResponseStreamWriter: ~Copyable {
+public protocol LambdaResponseStreamWriter {
     /// Write a response part into the stream. The HTTP response is started lazily before the first call to `write(_:)`.
     /// Bytes written to the writer are streamed continually.
     func write(_ buffer: ByteBuffer) async throws
     /// End the response stream and the underlying HTTP response.
-    consuming func finish()
+    func finish() async throws
     /// Write a response part into the stream and end the response stream as well as the underlying HTTP response.
-    consuming func writeAndFinish(_ buffer: ByteBuffer) async throws
+    func writeAndFinish(_ buffer: ByteBuffer) async throws
 }
 ```
 
-It is important to note that `LambdaResponseStreamWriter` will be non-copyable, with the `finish()` and
-`writeAndFinish(_:)` functions having the `consuming` ownership keyword. This is so that the compiler can enforce the
-restriction of not being able to call `write(_:)` after any of the finishing functions have been called. The compiler
-can also prevent the finishing functions from being called multiple times. If the user does not call `finish()`, the
-library will automatically finish the stream after the last `write` utilizing the writers `deinit`.
+If the user does not call `finish()`, the library will automatically finish the stream after the last `write`.
+Appropriate errors will be thrown if `finish()` is called multiple times, or if `write`/`writeAndFinish` is called after
+`finish()`.
 
 ### LambdaContext
 
@@ -278,7 +279,7 @@ public protocol StreamingLambdaHandler {
     ///     headers will be sent.
     ///   - If ``LambdaResponseStreamWriter.finish()`` has already been called before the error is thrown, the
     ///     error will be logged.
-    mutating func handle(_ event: ByteBuffer, responseWriter: consuming some LambdaResponseStreamWriter, context: LambdaContext) async throws
+    mutating func handle(_ event: ByteBuffer, responseWriter: some LambdaResponseStreamWriter, context: LambdaContext) async throws
 }
 ```
 
@@ -303,7 +304,7 @@ An implementation that sends the number 1 to 10 every 500ms could look like this
 struct SendNumbersWithPause: StreamingLambdaHandler {
     func handle(
         _ event: ByteBuffer,
-        responseWriter: consuming some LambdaResponseStreamWriter,
+        responseWriter: some LambdaResponseStreamWriter,
         context: LambdaContext
     ) async throws {
         for i in 1...10 {
@@ -357,12 +358,13 @@ any background work after the result has been sent to the AWS Lambda control pla
 simply serves as a mechanism to return the output without explicitly returning from the `handle` function.
 
 ```swift
-public protocol LambdaResponseWriter<Output>: ~Copyable {
+public protocol LambdaResponseWriter<Output> {
     associatedtype Output
 
     /// Sends the generic Output object (representing the computed result of the handler)
     /// to the AWS Lambda response endpoint.
-    consuming func write(_: Output) async throws
+    /// An error will be thrown if this function is called more than once.
+    func write(_: Output) async throws
 }
 
 public protocol LambdaWithBackgroundProcessingHandler {
@@ -377,7 +379,7 @@ public protocol LambdaWithBackgroundProcessingHandler {
     /// Agnostic to JSON encoding/decoding
     func handle(
         _ event: Event,
-        outputWriter: consuming some LambdaResponseWriter<Output>,
+        outputWriter: some LambdaResponseWriter<Output>,
         context: LambdaContext
     ) async throws
 }
@@ -400,7 +402,7 @@ struct BackgroundProcessingHandler: LambdaWithBackgroundProcessingHandler {
 
     func handle(
         _ event: Event,
-        outputWriter: consuming some LambdaResponseWriter<Output>,
+        outputWriter: some LambdaResponseWriter<Output>,
         context: LambdaContext
     ) async throws {
         // Return result to the Lambda control plane
@@ -460,13 +462,13 @@ public final class LambdaRuntime<Handler>: ServiceLifecycle.Service, Sendable
     ///                        ``NIOSingletons.posixEventLoopGroup``.
     /// - Parameter logger: A logger
     public init(
-        handler: consuming sending Handler,
+        handler: sending Handler,
         eventLoop: EventLoop = Lambda.defaultEventLoop,
         logger: Logger = Logger(label: "Lambda")
     )
 
     /// Create a LambdaRuntime by passing a ``StreamingLambdaHandler``.
-    public convenience init(handler: consuming sending Handler)
+    public convenience init(handler: sending Handler)
 
     /// Starts the LambdaRuntime by connecting to the Lambda control plane to ask
     /// for events to process. If the environment variable AWS_LAMBDA_RUNTIME_API is
@@ -569,7 +571,7 @@ public struct LambdaHandlerAdapter<
 
     /// 1. Call the `self.handler.handle(...)` with `event` and `context`.
     /// 2. Pass the generic `Output` object returned from `self.handler.handle(...)` to `outputWriter.write(_:)`
-    public func handle(_ event: Event, outputWriter: consuming some LambdaResponseWriter<Output>, context: LambdaContext) async throws
+    public func handle(_ event: Event, outputWriter: some LambdaResponseWriter<Output>, context: LambdaContext) async throws
 }
 ```
 
@@ -643,7 +645,7 @@ public struct LambdaCodableAdapter<
     /// and the `LambdaContext`.
     public mutating func handle(
         _ request: ByteBuffer,
-        responseWriter: consuming some LambdaResponseStreamWriter,
+        responseWriter: some LambdaResponseStreamWriter,
         context: LambdaContext
     ) async throws
 }
@@ -721,19 +723,19 @@ handle encoding/decoding themselves:
 public struct StreamingClosureHandler: StreamingLambdaHandler {
 
     public init(
-        body: @escaping sending (ByteBuffer, consuming LambdaResponseStreamWriter, LambdaContext) async throws -> ()
+        body: @escaping sending (ByteBuffer, LambdaResponseStreamWriter, LambdaContext) async throws -> ()
     )
 
     public func handle(
         _ request: ByteBuffer,
-        responseWriter: consuming LambdaResponseStreamWriter,
+        responseWriter: LambdaResponseStreamWriter,
         context: LambdaContext
     ) async throws
 }
 
 extension LambdaRuntime {
     public init(
-        body: @escaping sending (ByteBuffer, consuming LambdaResponseStreamWriter, LambdaContext) async throws -> ()
+        body: @escaping sending (ByteBuffer, LambdaResponseStreamWriter, LambdaContext) async throws -> ()
     )
 }
 ```
@@ -766,7 +768,7 @@ Its API would look like this:
 /// The response can be empty, a single ByteBuffer or a response stream.
 public struct LambdaResponse {
     /// A writer to be used when creating a streamed response.
-    public struct Writer: ~Copyable {
+    public struct Writer {
         /// Writes data to the response stream
         public func write(_ byteBuffer: ByteBuffer) async throws
         /// Closes off the response stream
@@ -840,7 +842,7 @@ For handlers conforming to the `LambdaHandler` protocol, we considered extending
 add background work can override this function in their `LambdaHandler` conforming object.
 
 ```swift
-public protocol LambdaHandler: ~Copyable {
+public protocol LambdaHandler {
     associatedtype Event
     associatedtype Output