Swift 5 and native Result Type

Interstellar.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Sources/Interstellar/Observable+Result.swift

@@ -6,66 +6,77 @@
 //  Copyright © 2015 nerdgeschoss GmbH. All rights reserved.
 //
 
+public protocol ResultType {
+  associatedtype Success
+  var _result: Result<Success,Error> {get}
+}
+
+extension Result: ResultType {
+  public var _result: Result<Success, Error> {
+    return self as! Result<Success, Error>
+  }
+}
+
 public extension Observable where T : ResultType {
     /// Observables containing a Result<T> can be chained to only continue in the success case.
-    public func then<U>(_ transform: @escaping (T.Value) -> Result<U>) -> Observable<Result<U>> {
-        return map { $0.result.flatMap(transform) }
+    func then<U>(_ transform: @escaping (T.Success) -> Result<U, Error>) -> Observable<Result<U, Error>> {
+        return map { $0._result.flatMap(transform) }
     }
 
     /// Observables containing a Result<T> can be chained to only continue in the success case.
-    public func then<U>(_ transform: @escaping (T.Value) -> U) -> Observable<Result<U>> {
-        return map { $0.result.map(transform) }
+    func then<U>(_ transform: @escaping (T.Success) -> U) -> Observable<Result<U, Error>> {
+        return map { $0._result.map(transform) }
     }
-    
+
     /// Observables containing a Result<T> can be chained to only continue in the success case.
-    public func then<U>(_ transform: @escaping (T.Value) throws -> U) -> Observable<Result<U>> {
-        return map { $0.result.flatMap(transform) }
+    func then<U>(_ transform: @escaping (T.Success) throws -> U) -> Observable<Result<U,Error>> {
+      return map { $0._result.flatMap { value in Result { try transform(value) } }}
     }
 
     /// Observables containing a Result<T> can be chained to only continue in the success case.
-    public func then<U>(_ transform: @escaping (T.Value) -> Observable<U>) -> Observable<Result<U>> {
+    func then<U>(_ transform: @escaping (T.Success) -> Observable<U>) -> Observable<Result<U,Error>> {
         return flatMap { [options] in
-            let observable = Observable<Result<U>>(options: options)
-            switch $0.result {
+            let observable = Observable<Result<U,Error>>(options: options)
+            switch $0._result {
             case let .success(v): transform(v).subscribe { observable.update(.success($0)) }
-            case let .error(error): observable.update(.error(error))
+            case let .failure(error): observable.update(.failure(error))
             }
             return observable
         }
     }
 
     /// Observables containing a Result<T> can be chained to only continue in the success case.
-    public func then<U>(_ transform: @escaping (T.Value) -> Observable<Result<U>>) -> Observable<Result<U>> {
+    func then<U>(_ transform: @escaping (T.Success) -> Observable<Result<U, Error>>) -> Observable<Result<U, Error>> {
         return flatMap { [options] in
-            switch $0.result {
+            switch $0._result {
             case let .success(v): return transform(v)
-            case let .error(error): return Observable<Result<U>>(Result.error(error), options: options)
+            case let .failure(error): return Observable<Result<U, Error>>(Result.failure(error), options: options)
             }
         }
     }
 
     /// Only subscribe to successful events.
-    @discardableResult public func next(_ block: @escaping (T.Value) -> Void) -> Observable<T> {
+    @discardableResult func next(_ block: @escaping (T.Success) -> Void) -> Observable<T> {
         subscribe { result in
-            if let value = result.value {
+            if let value = try? result._result.get() {
                 block(value)
             }
         }
         return self
     }
 
     /// Only subscribe to errors.
-    @discardableResult public func error(_ block: @escaping (Error) -> Void) -> Observable<T> {
+    @discardableResult func error(_ block: @escaping (Error) -> Void) -> Observable<T> {
         subscribe { result in
-            if let error = result.error {
+            if case let Result.failure(error) = result._result {
                 block(error)
             }
         }
         return self
     }
 
     /// Peek at the value of the observable.
-    public func peek() -> T.Value? {
-        return self.value?.value
+    func peek() -> T.Success? {
+        return try? self.value?._result.get()
     }
 }

Sources/Interstellar/Observable.swift

@@ -78,8 +78,8 @@ public final class Observable<T>: Unsubscribable {
     @discardableResult public func subscribe(_ observer: @escaping (T) -> Void) -> ObserverToken {
         var token: ObserverToken!
         mutex.lock {
-            let newHashValue = (observers.keys.map({$0.hashValue}).max() ?? -1) + 1
-            token = ObserverToken(observable: self, hashValue: newHashValue)
+            let newHashValue = (observers.keys.map({$0.token}).max() ?? -1) + 1
+            token = ObserverToken(observable: self, token: newHashValue)
             if !(options.contains(.Once) && value != nil) {
                 observers[token] = observer
             }
@@ -154,10 +154,10 @@ extension Observable {
     /**
     Creates a new observable with a transform applied. The value of the observable will be wrapped in a Result<T> in case the transform throws.
     */
-    public func map<U>(_ transform: @escaping (T) throws -> U) -> Observable<Result<U>> {
-        let observable = Observable<Result<U>>(options: options)
+    public func map<U>(_ transform: @escaping (T) throws -> U) -> Observable<Result<U, Error>> {
+        let observable = Observable<Result<U, Error>>(options: options)
         subscribe { value in
-            observable.update(Result(block: { return try transform(value) }))
+            observable.update(Result(catching: { return try transform(value) }))
         }
         return observable
     }

Sources/Interstellar/ObserverToken.swift

@@ -21,18 +21,22 @@
 /// Observer tokens are created by observables to hande unsubscription. You are not supposed to create them directly.
 public final class ObserverToken: Hashable {
     private weak var observable: Unsubscribable?
-    public let hashValue: Int
+    public let token: Int
 
-    internal init (observable: Unsubscribable, hashValue: Int) {
+    internal init (observable: Unsubscribable, token: Int) {
         self.observable = observable
-        self.hashValue = hashValue
+        self.token = token
     }
 
     public func unsubscribe() {
         observable?.unsubscribe(self)
     }
+
+    public func hash(into hasher: inout Hasher) {
+      hasher.combine(token)
+    }
 }
 
 public func ==(lhs: ObserverToken, rhs: ObserverToken) -> Bool {
-    return lhs.hashValue == rhs.hashValue
+    return lhs.token == rhs.token
 }