RAS changes.

Author: mluisbrown

Examples/CaseStudies/SwiftUICaseStudies/FactClient.swift

@@ -26,8 +26,7 @@ extension FactClient {
             return "\(number) is a good number Brent"
           }
         }
-        .setFailureType(to: Error.self)
-        .eraseToEffect()
+        .promoteError(Error.self)
       }
     )
   #else

Sources/ComposableArchitecture/Beta/Concurrency.swift

@@ -37,8 +37,8 @@ import SwiftUI
     /// - Returns: An effect wrapping the given asynchronous work.
     public static func task(
       priority: TaskPriority? = nil,
-      operation: @escaping @Sendable () async -> Output
-    ) -> Self where Failure == Never {
+      operation: @escaping @Sendable () async -> Value
+    ) -> Self where Error == Never {
       var task: Task<Void, Never>?
       return .future { callback in
         task = Task(priority: priority) {
@@ -48,8 +48,7 @@ import SwiftUI
           callback(.success(output))
         }
       }
-      .handleEvents(receiveCancel: { task?.cancel() })
-      .eraseToEffect()
+      .on(disposed: { task?.cancel() })
     }
 
     /// Wraps an asynchronous unit of work in an effect.
@@ -82,26 +81,27 @@ import SwiftUI
     /// - Returns: An effect wrapping the given asynchronous work.
     public static func task(
       priority: TaskPriority? = nil,
-      operation: @escaping @Sendable () async throws -> Output
-    ) -> Self where Failure == Error {
-      Deferred<Publishers.HandleEvents<PassthroughSubject<Output, Failure>>> {
-        let subject = PassthroughSubject<Output, Failure>()
+      operation: @escaping @Sendable () async throws -> Value
+    ) -> Self where Error == Swift.Error {
+      deferred {
+        let subject = Signal<Value, Error>.pipe()
         let task = Task(priority: priority) {
           do {
             try Task.checkCancellation()
             let output = try await operation()
             try Task.checkCancellation()
-            subject.send(output)
-            subject.send(completion: .finished)
+            subject.input.send(value: output)
+            subject.input.sendCompleted()
           } catch is CancellationError {
-            subject.send(completion: .finished)
+            subject.input.sendCompleted()
           } catch {
-            subject.send(completion: .failure(error))
+            subject.input.send(error: error)
           }
         }
-        return subject.handleEvents(receiveCancel: task.cancel)
+
+        return subject.output.producer
+          .on(disposed: task.cancel)
       }
-      .eraseToEffect()
     }
   }
 

Tests/ComposableArchitectureTests/EffectTests.swift

@@ -179,8 +179,7 @@ final class EffectTests: XCTestCase {
         expectation.fulfill()
         return 42
       }
-      .sink(receiveValue: { result = $0 })
-      .store(in: &self.cancellables)
+      .startWithValues { result = $0 }
       self.wait(for: [expectation], timeout: 0)
       XCTAssertEqual(result, 42)
     }
@@ -191,24 +190,23 @@ final class EffectTests: XCTestCase {
     let expectation = self.expectation(description: "Complete")
     struct MyError: Error {}
     var result: Error?
-    Effect<Int, Error>.task {
+    let disposable = Effect<Int, Error>.task {
       expectation.fulfill()
       throw MyError()
     }
-    .sink(
-      receiveCompletion: {
-        switch $0 {
-        case .finished:
-          XCTFail()
-        case let .failure(error):
-          result = error
-        }
+    .on(
+      failed: { error in
+        result = error
       },
-      receiveValue: { _ in XCTFail() }
-    )
-    .store(in: &self.cancellables)
+      value: { _ in
+        XCTFail()
+      }
+    ).logEvents()
+    .start()
+
     self.wait(for: [expectation], timeout: 0)
     XCTAssertNotNil(result)
+    disposable.dispose()
   }
 
   func testCancellingTask() {
@@ -228,12 +226,11 @@ final class EffectTests: XCTestCase {
     let expectation = self.expectation(description: "Complete")
     Effect<Int, Error>.task {
       try await work()
-    }
-    .sink(
-      receiveCompletion: { _ in expectation.fulfill() },
-      receiveValue: { _ in XCTFail() }
-    )
-    .store(in: &self.cancellables)
+    }.on(
+      completed: { expectation.fulfill() },
+      value: { _ in XCTFail() }
+    ).start()
+
     self.wait(for: [expectation], timeout: 0.2)
   }
   #endif