Revision: Remove ~Copyable from StreamingLambdaHandler + Update EventLoop paragraph

Author: aryan-25

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

@@ -28,12 +28,11 @@ Versions:
 #### EventLoop interfaces
 
 The current API extensively uses the `EventLoop` family of interfaces from SwiftNIO in many areas. To use these
-interfaces correctly though, it requires developers to exercise great care and be aware of certain details such as never
-running blocking code on the same `EventLoop` the library uses. Developers also need to understand the various transform
-methods that are used to work with `EventLoop`s and `EventLoopFuture`s. This results in a lot of cognitive complexity
-and makes the code in the current API hard to reason about and maintain. For these reasons, the overarching trend in the
-Swift on Server ecosystem is to shift to newer, more readable, Swift concurrency constructs and de-couple from
-SwiftNIO's `EventLoop` interfaces.
+interfaces correctly though, it requires developers to exercise great care and understand the various transform methods
+that are used to work with `EventLoop`s and `EventLoopFuture`s. This results in a lot of cognitive complexity and makes
+the code in the current API hard to reason about and maintain. For these reasons, the overarching trend in the Swift on
+Server ecosystem is to shift to newer, more readable, Swift concurrency constructs and de-couple from SwiftNIO's
+`EventLoop` interfaces.
 
 #### No ownership of the main() function
 
@@ -262,15 +261,15 @@ this protocol and instead use the `LambdaHandler` protocol defined below.
 
 ```swift
 /// The base StreamingLambdaHandler protocol
-public protocol StreamingLambdaHandler: ~Copyable {
+public protocol StreamingLambdaHandler {
     /// The business logic of the Lambda function
     /// - Parameters:
     ///   - event: The invocation's input data
     ///   - responseWriter: A ``LambdaResponseStreamWriter`` to write the invocation's response to.
     ///                     If no response or error is written to the `responseWriter` it will
     ///                     report an error to the invoker.
     ///   - context: The LambdaContext containing the invocation's metadata
-    /// - Throws
+    /// - Throws:
     /// How the thrown error will be handled by the runtime:
     ///   - An invocation error will be reported if the error is thrown before the first call to
     ///     ``LambdaResponseStreamWriter.write(_:)``.
@@ -296,7 +295,7 @@ plane, since the `handle(...)` function is free to implement any background work
 `responseWriter.finish()`.
 
 The protocol is defined in a way that supports a broad range of use-cases. The handle method is marked as `mutating` to
-allow handlers to be implemented with a `struct`. Users can opt to even mark the handler as non-copyable.
+allow handlers to be implemented with a `struct`.
 
 An implementation that sends the number 1 to 10 every 500ms could look like this:
 
@@ -451,7 +450,7 @@ provide support for `swift-service-lifecycle`.
 /// The LambdaRuntime object. This object communicates with the Lambda control plane
 /// to fetch work and report errors.
 public final class LambdaRuntime<Handler>: ServiceLifecycle.Service, Sendable
-    where Handler: StreamingLambdaHandler, Handler: ~Copyable
+    where Handler: StreamingLambdaHandler
 {
 
     /// Create a LambdaRuntime by passing a handler, an eventLoop and a logger.
@@ -792,7 +791,7 @@ The `StreamingLambdaHandler` would look like this:
 
 ```swift
 /// The base LambdaHandler protocol
-public protocol StreamingLambdaHandler: ~Copyable {
+public protocol StreamingLambdaHandler {
     /// The business logic of the Lambda function
     /// - Parameters:
     ///   - event: The invocation's input data