Merge pull request #42 from fggeraissate/use-native-result

Replace current Result for the native swift implementation

Author: vadymmarkov

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -15,7 +15,7 @@ Promise({
   return "String"
 }).always({ result in
   print("Always")
-  print(result.value ?? "")
+  print(try? result.get() ?? "")
 }).done({ value in
   print(value)
 }).fail({ error in

Playground.playground/Contents.swift

@@ -7,14 +7,14 @@ let barrierQueue = DispatchQueue(label: "When.BarrierQueue", attributes: [])
 
 public func when<T, U>(_ p1: Promise<T>, _ p2: Promise<U>) -> Promise<(T, U)> {
   return when([p1.asVoid(on: instantQueue), p2.asVoid(on: instantQueue)]).then(on: instantQueue) { _ in
-    (p1.state.result!.value!, p2.state.result!.value!)
+    (try! p1.state.result!.get(), try! p2.state.result!.get())
   }
 }
 
 public func when<T, U, V>(_ p1: Promise<T>, _ p2: Promise<U>, _ p3: Promise<V>) -> Promise<(T, U, V)> {
   return when([p1.asVoid(on: instantQueue), p2.asVoid(on: instantQueue), p3.asVoid(on: instantQueue)])
     .then(on: instantQueue, ({ _ in
-      (p1.state.result!.value!, p2.state.result!.value!, p3.state.result!.value!)
+      (try! p1.state.result!.get(), try! p2.state.result!.get(), try! p3.state.result!.get())
     }))
 }
 
@@ -31,7 +31,7 @@ public func when<T>(_ promises: [Promise<T>]) -> Promise<[T]> {
           barrierQueue.sync {
             resolved += 1
             if resolved == total {
-              masterPromise.resolve(promises.map{ $0.state.result!.value! })
+              masterPromise.resolve(promises.map{ try! $0.state.result!.get() })
             }
           }
         })

Sources/Functions.swift

@@ -3,5 +3,5 @@ import Dispatch
 
 struct Observer<T> {
   let queue: DispatchQueue
-  let notify: (Result<T>) -> Void
+  let notify: (Result<T, Error>) -> Void
 }

Sources/Observer.swift

@@ -4,7 +4,7 @@ import Dispatch
 open class Promise<T> {
   public typealias DoneHandler = (T) -> Void
   public typealias FailureHandler = (Error) -> Void
-  public typealias CompletionHandler = (Result<T>) -> Void
+  public typealias CompletionHandler = (Result<T, Error>) -> Void
 
   public let key = UUID().uuidString
   let queue: DispatchQueue
@@ -144,7 +144,7 @@ open class Promise<T> {
     }
   }
 
-  private func notify(_ result: Result<T>) {
+  private func notify(_ result: Result<T, Error>) {
     switch result {
     case let .success(value):
       for doneHandler in doneHandlers {

Sources/Promise.swift

@@ -34,12 +34,12 @@ public enum State<T>: Equatable {
     }
   }
 
-  public var result: Result<T>? {
+  public var result: Result<T, Error>? {
     switch self {
     case let .resolved(value):
-      return .success(value: value)
+        return .success(value)
     case let .rejected(error):
-      return .failure(error: error)
+        return .failure(error)
     case .pending:
       return nil
     }

Sources/Result.swift

@@ -44,7 +44,7 @@ class PromiseSpec: QuickSpec {
 
           it("sets values") {
             expect(promise.state).to(equal(state))
-            expect(promise.state.result?.value).to(equal(state.result?.value))
+            expect(try! promise.state.result?.get()).to(equal(try! state.result?.get()))
             expect(promise.queue === queue).to(beTrue())
           }
         }
@@ -64,8 +64,11 @@ class PromiseSpec: QuickSpec {
             promise
               .fail({ object in
                 expect(promise.state.isRejected).to(beTrue())
-                expect(promise.state.result?.value).to(beNil())
-                expect(promise.state.result?.error is SpecError).to(beTrue())
+                guard case .failure(let error) = promise.state.result else {
+                    fail()
+                    return
+                }
+                 expect(error is SpecError).to(beTrue())
 
                 failExpectation.fulfill()
               })
@@ -89,8 +92,7 @@ class PromiseSpec: QuickSpec {
             promise
               .done({ object in
                 expect(promise.state.isResolved).to(beTrue())
-                expect(promise.state.result?.value).to(equal(string))
-                expect(promise.state.result?.error).to(beNil())
+                expect(try! promise.state.result?.get()).to(equal(string))
 
                 doneExpectation.fulfill()
               })
@@ -118,8 +120,7 @@ class PromiseSpec: QuickSpec {
             promise.done { value in
               expect(value).to(equal(string))
               expect(promise.state.isResolved).to(beTrue())
-              expect(promise.state.result?.value).to(equal(string))
-              expect(promise.state.result?.error).to(beNil())
+              expect(try! promise.state.result?.get()).to(equal(string))
 
               doneExpectation.fulfill()
             }
@@ -143,8 +144,11 @@ class PromiseSpec: QuickSpec {
             .fail({ error in
               expect(error is SpecError).to(beTrue())
               expect(promise.state.isRejected).to(beTrue())
-              expect(promise.state.result?.value).to(beNil())
-              expect(promise.state.result?.error is SpecError).to(beTrue())
+              guard case .failure(let promiseError) = promise.state.result else {
+                  fail()
+                  return
+              }
+              expect(promiseError is SpecError).to(beTrue())
 
               failExpectation.fulfill()
             })
@@ -179,8 +183,7 @@ class PromiseSpec: QuickSpec {
             .done({ object in
               expect(object).to(equal(string))
               expect(promise.state.isResolved).to(beTrue())
-              expect(promise.state.result?.value).to(equal(string))
-              expect(promise.state.result?.error).to(beNil())
+              expect(try! promise.state.result?.get()).to(equal(string))
 
               doneExpectation.fulfill()
             })
@@ -259,7 +262,11 @@ class PromiseSpec: QuickSpec {
                 fail("Handler should not be called")
               })
               .always({ result in
-                expect((result.error as? PromiseError) == .cancelled).to(beTrue())
+                guard case .failure(let error) = result else {
+                    fail()
+                    return
+                }
+                expect((error as? PromiseError) == .cancelled).to(beTrue())
                 failExpectation.fulfill()
               })
 

Sources/State.swift

@@ -76,7 +76,7 @@ class StateSpec: QuickSpec {
             expect(nextState.isPending).to(beFalse())
             expect(nextState.isResolved).to(beTrue())
             expect(nextState.isRejected).to(beFalse())
-            expect(nextState.result?.value).to(equal(11))
+            expect(try! nextState.result?.get()).to(equal(11))
           }
         }
       }
@@ -109,12 +109,16 @@ class StateSpec: QuickSpec {
             let nextState: State<Int> = state.map { value in
               return 11
             }
+            
+            guard case .failure(let error) = nextState.result else {
+                fail()
+                return
+            }
 
             expect(nextState.isPending).to(beFalse())
             expect(nextState.isResolved).to(beFalse())
             expect(nextState.isRejected).to(beTrue())
-            expect(nextState.result?.value).to(beNil())
-            expect(nextState.result?.error is SpecError).to(beTrue())
+            expect(error is SpecError).to(beTrue())
           }
         }
       }