KCD/Future.swift

   1 //
   2 //  Future.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2018/01/13.
   6 //  Copyright © 2018年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10
  11 enum Result<T> {
  12
  13     case value(T)
  14
  15     case error(Error)
  16
  17     init(_ value: T) {
  18         self = .value(value)
  19     }
  20     init(_ error: Error) {
  21         self = .error(error)
  22     }
  23 }
  24 extension Result {
  25
  26     var value: T? {
  27         if case let .value(value) = self { return value }
  28         return nil
  29     }
  30     var error: Error? {
  31         if case let .error(error) = self { return error }
  32         return nil
  33     }
  34 }
  35
  36 enum FutureError: Error {
  37
  38     case unsolvedFuture
  39
  40     case noSuchElement
  41 }
  42
  43 final class Future<T> {
  44
  45     private let semaphore: DispatchSemaphore?
  46
  47     private var callbacks: [(Result<T>) -> Void] = []
  48
  49     fileprivate var result: Result<T>? {
  50         willSet {
  51             if result != nil {
  52                 fatalError("Result already seted.")
  53             }
  54         }
  55         didSet {
  56             guard let result = self.result else {
  57                 fatalError("set nil to result.")
  58             }
  59
  60             callbacks.forEach { f in f(result) }
  61             semaphore?.signal()
  62         }
  63     }
  64
  65     var isCompleted: Bool {
  66         return result != nil
  67     }
  68     var value: Result<T>? {
  69         return result
  70     }
  71
  72     /// Life cycle
  73     init() {
  74
  75         // for await()
  76         semaphore = DispatchSemaphore(value: 1)
  77         semaphore?.wait()
  78     }
  79
  80     init(in queue: DispatchQueue = .global(), _ block: @escaping () throws -> T) {
  81
  82         semaphore = DispatchSemaphore(value: 1)
  83         semaphore?.wait()
  84
  85         queue.async {
  86
  87             defer { self.semaphore?.signal() }
  88
  89             do {
  90                 self.result = Result(try block())
  91             } catch {
  92                 self.result = Result(error)
  93             }
  94         }
  95     }
  96
  97     init(_ result: Result<T>) {
  98
  99         semaphore = nil
 100
 101         self.result = result
 102     }
 103     convenience init(_ value: T) {
 104
 105         self.init(Result(value))
 106     }
 107     convenience init(_ error: Error) {
 108
 109         self.init(Result(error))
 110     }
 111
 112     deinit {
 113         semaphore?.signal()
 114     }
 115 }
 116
 117 extension Future {
 118
 119     ///
 120     @discardableResult
 121     func await() -> Self {
 122
 123         if result == nil {
 124             semaphore?.wait()
 125             semaphore?.signal()
 126         }
 127
 128         return self
 129     }
 130
 131     @discardableResult
 132     func onComplete(_ callback: @escaping (Result<T>) -> Void) -> Self {
 133
 134         if let r = result {
 135             callback(r)
 136         } else {
 137             callbacks.append(callback)
 138         }
 139
 140         return self
 141     }
 142
 143     @discardableResult
 144     func onSuccess(_ callback: @escaping (T) -> Void) -> Self {
 145
 146         onComplete { result in
 147             if case let .value(v) = result {
 148                 callback(v)
 149             }
 150         }
 151
 152         return self
 153     }
 154
 155     @discardableResult
 156     func onFailure(_ callback: @escaping (Error) -> Void) -> Self {
 157
 158         onComplete { result in
 159             if case let .error(e) = result {
 160                 callback(e)
 161             }
 162         }
 163
 164         return self
 165     }
 166 }
 167
 168 extension Future {
 169
 170     ///
 171     func transform<U>(_ s: @escaping (T) -> U, _ f: @escaping (Error) -> Error) -> Future<U> {
 172
 173         return transform { result in
 174             switch result {
 175             case let .value(value): return Result(s(value))
 176             case let .error(error): return Result(f(error))
 177             }
 178         }
 179     }
 180
 181     func transform<U>(_ s: @escaping (Result<T>) -> Result<U>) ->Future<U> {
 182
 183         return Promise()
 184             .complete {
 185                 self.await().value.map(s) ?? Result(FutureError.unsolvedFuture)
 186             }
 187             .future
 188     }
 189
 190     func map<U>(_ t: @escaping (T) -> U) -> Future<U> {
 191
 192         return transform(t, { $0 })
 193     }
 194
 195     func flatMap<U>(_ t: @escaping (T) -> Future<U>) -> Future<U> {
 196
 197         return Promise()
 198             .completeWith {
 199                 switch self.await().value {
 200                 case .value(let v)?: return t(v)
 201                 case .error(let e)?: return Future<U>(e)
 202                 case .none: fatalError("Future not complete")
 203                 }
 204             }
 205             .future
 206     }
 207
 208     func filter(_ f: @escaping (T) -> Bool) -> Future<T> {
 209
 210         return Promise()
 211             .complete {
 212                 if case let .value(v)? = self.await().value, f(v) {
 213                     return Result(v)
 214                 }
 215                 return Result(FutureError.noSuchElement)
 216             }
 217             .future
 218     }
 219
 220     func recover(_ s: @escaping (Error) throws -> T) -> Future<T> {
 221
 222         return transform { result in
 223             do {
 224                 return try result.error.map { error in Result(try s(error)) } ?? Result(FutureError.unsolvedFuture)
 225             } catch {
 226                 return Result(error)
 227             }
 228         }
 229     }
 230
 231     @discardableResult
 232     func andThen(_ f: @escaping (Result<T>) -> Void) -> Future<T> {
 233
 234         return Promise<T>()
 235             .complete {
 236                 guard let result = self.await().result else { fatalError("Future not complete") }
 237
 238                 f(result)
 239                 return result
 240             }
 241             .future
 242     }
 243 }
 244
 245 private extension Future {
 246
 247     func complete(_ result: Result<T>) {
 248
 249         self.result = result
 250     }
 251 }
 252
 253 private let promiseQueue = DispatchQueue(label: "Promise", attributes: .concurrent)
 254 final class Promise<T> {
 255
 256     let future: Future<T> = Future<T>()
 257
 258     ///
 259     func complete(_ result: Result<T>) {
 260
 261         future.complete(result)
 262     }
 263     func success(_ value: T) {
 264
 265         complete(Result(value))
 266     }
 267     func failure(_ error: Error) {
 268
 269         complete(Result(error))
 270     }
 271
 272     func complete(_ completor: @escaping () -> Result<T>) -> Self {
 273
 274         promiseQueue.async {
 275             self.complete(completor())
 276         }
 277
 278         return self
 279     }
 280
 281     func completeWith(_ completor: @escaping () -> Future<T>) -> Self {
 282
 283         promiseQueue.async {
 284             completor()
 285                 .onSuccess {
 286                     self.success($0)
 287                 }
 288                 .onFailure {
 289                     self.failure($0)
 290             }
 291         }
 292
 293         return self
 294     }
 295 }