5 // Created by Hori,Masaki on 2018/01/13.
6 // Copyright © 2018年 Hori,Masaki. All rights reserved.
19 // self = .value(value)
22 // init(_ error: Error) {
24 // self = .error(error)
31 if case let .value(value) = self { return value }
38 if case let .error(error) = self { return error }
44 enum FutureError: Error {
51 final class Future<T> {
53 private let semaphore: DispatchSemaphore?
55 private var callbacks: [(Result<T>) -> Void] = []
57 fileprivate var result: Result<T>? {
63 fatalError("Result already seted.")
69 guard let result = self.result else {
71 fatalError("set nil to result.")
74 callbacks.forEach { f in f(result) }
81 var isCompleted: Bool {
86 var value: Result<T>? {
95 semaphore = DispatchSemaphore(value: 0)
98 init(in queue: DispatchQueue = .global(), _ block: @escaping () throws -> T) {
101 semaphore = DispatchSemaphore(value: 0)
105 defer { self.semaphore?.signal() }
109 self.result = .value(try block())
113 self.result = .error(error)
118 init(_ result: Result<T>) {
125 convenience init(_ value: T) {
127 self.init(.value(value))
130 convenience init(_ error: Error) {
132 self.init(.error(error))
145 func await() -> Self {
157 func onComplete(_ callback: @escaping (Result<T>) -> Void) -> Self {
165 callbacks.append(callback)
172 func onSuccess(_ callback: @escaping (T) -> Void) -> Self {
174 onComplete { result in
176 if case let .value(v) = result {
186 func onFailure(_ callback: @escaping (Error) -> Void) -> Self {
188 onComplete { result in
190 if case let .error(e) = result {
203 func transform<U>(_ s: @escaping (T) -> U, _ f: @escaping (Error) -> Error) -> Future<U> {
205 return transform { result in
209 case let .value(value): return .value(s(value))
211 case let .error(error): return .error(f(error))
217 func transform<U>(_ s: @escaping (Result<T>) -> Result<U>) ->Future<U> {
222 self.await().value.map(s) ?? .error(FutureError.unsolvedFuture)
227 func map<U>(_ t: @escaping (T) -> U) -> Future<U> {
229 return transform(t, { $0 })
232 func flatMap<U>(_ t: @escaping (T) -> Future<U>) -> Future<U> {
237 switch self.await().value {
239 case .value(let v)?: return t(v)
241 case .error(let e)?: return Future<U>(e)
243 case .none: fatalError("Future not complete")
250 func filter(_ f: @escaping (T) -> Bool) -> Future<T> {
255 if case let .value(v)? = self.await().value, f(v) {
260 return .error(FutureError.noSuchElement)
265 func recover(_ s: @escaping (Error) throws -> T) -> Future<T> {
267 return transform { result in
271 return try result.error.map { error in .value(try s(error)) } ?? .error(FutureError.unsolvedFuture)
281 func andThen(_ f: @escaping (Result<T>) -> Void) -> Future<T> {
286 guard let result = self.await().result else {
288 fatalError("Future not complete")
299 private extension Future {
301 func complete(_ result: Result<T>) {
307 private let promiseQueue = DispatchQueue(label: "Promise", attributes: .concurrent)
308 final class Promise<T> {
310 let future: Future<T> = Future<T>()
313 func complete(_ result: Result<T>) {
315 future.complete(result)
318 func success(_ value: T) {
320 complete(.value(value))
323 func failure(_ error: Error) {
325 complete(.error(error))
328 func complete(_ completor: @escaping () -> Result<T>) -> Self {
332 self.complete(completor())
338 func completeWith(_ completor: @escaping () -> Future<T>) -> Self {