@@ -28,7 +28,7 @@ public final class Future<Value> {
28
28
/// - Parameter executionContext: ExecutionContext that will be used for all
29
29
/// transformations and handlers made on this Future. Default is .undefined.
30
30
public convenience init ( succeededWith result: Value , executionContext: ExecutionContext = . undefined) {
31
- self . init ( with: . value ( result) , executionContext: executionContext)
31
+ self . init ( with: . success ( result) , executionContext: executionContext)
32
32
}
33
33
34
34
/// Creates already finished Future with given error and context.
@@ -37,10 +37,10 @@ public final class Future<Value> {
37
37
/// - Parameter executionContext: ExecutionContext that will be used for all
38
38
/// transformations and handlers made on this Future. Default is .undefined.
39
39
public convenience init ( failedWith reason: Error , executionContext: ExecutionContext = . undefined) {
40
- self . init ( with: . error ( reason) , executionContext: executionContext)
40
+ self . init ( with: . failure ( reason) , executionContext: executionContext)
41
41
}
42
42
43
- internal init ( with result: Result < Value > ? = nil , executionContext: ExecutionContext ) {
43
+ internal init ( with result: Result < Value , Error > ? = nil , executionContext: ExecutionContext ) {
44
44
self . executionContext = executionContext
45
45
if let result = result {
46
46
self . state = . resulted( with: result)
@@ -73,7 +73,7 @@ public extension Future {
73
73
@discardableResult
74
74
func value( _ handler: @escaping ( Value ) -> Void ) -> Self {
75
75
observe { state in
76
- guard case let . resulted( . value ( value) ) = state else { return }
76
+ guard case let . resulted( . success ( value) ) = state else { return }
77
77
handler ( value)
78
78
}
79
79
return self
@@ -90,7 +90,7 @@ public extension Future {
90
90
@discardableResult
91
91
func error( _ handler: @escaping ( Error ) -> Void ) -> Self {
92
92
observe { state in
93
- guard case let . resulted( . error ( reason) ) = state else { return }
93
+ guard case let . resulted( . failure ( reason) ) = state else { return }
94
94
handler ( reason)
95
95
}
96
96
return self
@@ -141,14 +141,14 @@ public extension Future {
141
141
let future : Future < T > = . init( executionContext: executionContext)
142
142
observe { state in
143
143
switch state {
144
- case let . resulted( . value ( value) ) :
144
+ case let . resulted( . success ( value) ) :
145
145
do {
146
- try future. become ( . resulted( with: . value ( transformation ( value) ) ) )
146
+ try future. become ( . resulted( with: . success ( transformation ( value) ) ) )
147
147
} catch {
148
- future. become ( . resulted( with: . error ( error) ) )
148
+ future. become ( . resulted( with: . failure ( error) ) )
149
149
}
150
- case let . resulted( . error ( reason) ) :
151
- future. become ( . resulted( with: . error ( reason) ) )
150
+ case let . resulted( . failure ( reason) ) :
151
+ future. become ( . resulted( with: . failure ( reason) ) )
152
152
case . canceled:
153
153
future. become ( . canceled)
154
154
case . waiting: break
@@ -171,16 +171,16 @@ public extension Future {
171
171
let future : Future < T > = . init( executionContext: executionContext)
172
172
observe { state in
173
173
switch state {
174
- case let . resulted( . value ( value) ) :
174
+ case let . resulted( . success ( value) ) :
175
175
do {
176
176
try transformation ( value) . observe {
177
177
future. become ( $0)
178
178
}
179
179
} catch {
180
- future. become ( . resulted( with: . error ( error) ) )
180
+ future. become ( . resulted( with: . failure ( error) ) )
181
181
}
182
- case let . resulted( . error ( reason) ) :
183
- future. become ( . resulted( with: . error ( reason) ) )
182
+ case let . resulted( . failure ( reason) ) :
183
+ future. become ( . resulted( with: . failure ( reason) ) )
184
184
case . canceled:
185
185
future. become ( . canceled)
186
186
case . waiting: break
@@ -216,14 +216,14 @@ public extension Future {
216
216
let future : Future < Value > = . init( executionContext: executionContext)
217
217
observe { state in
218
218
switch state {
219
- case let . resulted( . value ( value) ) :
220
- future. become ( . resulted( with: . value ( value) ) )
221
- case let . resulted( . error ( reason) ) :
219
+ case let . resulted( . success ( value) ) :
220
+ future. become ( . resulted( with: . success ( value) ) )
221
+ case let . resulted( . failure ( reason) ) :
222
222
do {
223
223
try transformation ( reason)
224
224
future. become ( . canceled)
225
225
} catch {
226
- future. become ( . resulted( with: . error ( error) ) )
226
+ future. become ( . resulted( with: . failure ( error) ) )
227
227
}
228
228
case . canceled:
229
229
future. become ( . canceled)
@@ -247,13 +247,13 @@ public extension Future {
247
247
let future : Future < Value > = . init( executionContext: executionContext)
248
248
observe { state in
249
249
switch state {
250
- case let . resulted( . value ( value) ) :
251
- future. become ( . resulted( with: . value ( value) ) )
252
- case let . resulted( . error ( reason) ) :
250
+ case let . resulted( . success ( value) ) :
251
+ future. become ( . resulted( with: . success ( value) ) )
252
+ case let . resulted( . failure ( reason) ) :
253
253
do {
254
- try future. become ( . resulted( with: . value ( transformation ( reason) ) ) )
254
+ try future. become ( . resulted( with: . success ( transformation ( reason) ) ) )
255
255
} catch {
256
- future. become ( . resulted( with: . error ( error) ) )
256
+ future. become ( . resulted( with: . failure ( error) ) )
257
257
}
258
258
case . canceled:
259
259
future. become ( . canceled)
@@ -283,7 +283,7 @@ public extension Future {
283
283
internal extension Future {
284
284
enum State {
285
285
case waiting
286
- case resulted( with: Result < Value > )
286
+ case resulted( with: Result < Value , Error > )
287
287
case canceled
288
288
}
289
289
@@ -336,33 +336,33 @@ public func zip<T, U>(_ f1: Future<T>, _ f2: Future<U>) -> Future<(T, U)> {
336
336
337
337
f1. observe { state in
338
338
switch state {
339
- case let . resulted( . value ( value) ) :
339
+ case let . resulted( . success ( value) ) :
340
340
lock. lock ( )
341
341
defer { lock. unlock ( ) }
342
342
if case let ( _, r2? ) = results {
343
- future. become ( . resulted( with: . value ( ( value, r2) ) ) )
343
+ future. become ( . resulted( with: . success ( ( value, r2) ) ) )
344
344
} else {
345
345
results = ( value, nil )
346
346
}
347
- case let . resulted( . error ( reason) ) :
348
- future. become ( . resulted( with: . error ( reason) ) )
347
+ case let . resulted( . failure ( reason) ) :
348
+ future. become ( . resulted( with: . failure ( reason) ) )
349
349
case . canceled:
350
350
future. become ( . canceled)
351
351
case . waiting: break
352
352
}
353
353
}
354
354
f2. observe { state in
355
355
switch state {
356
- case let . resulted( . value ( value) ) :
356
+ case let . resulted( . success ( value) ) :
357
357
lock. lock ( )
358
358
defer { lock. unlock ( ) }
359
359
if case let ( r1? , _) = results {
360
- future. become ( . resulted( with: . value ( ( r1, value) ) ) )
360
+ future. become ( . resulted( with: . success ( ( r1, value) ) ) )
361
361
} else {
362
362
results = ( nil , value)
363
363
}
364
- case let . resulted( . error ( reason) ) :
365
- future. become ( . resulted( with: . error ( reason) ) )
364
+ case let . resulted( . failure ( reason) ) :
365
+ future. become ( . resulted( with: . failure ( reason) ) )
366
366
case . canceled:
367
367
future. become ( . canceled)
368
368
case . waiting: break
@@ -388,14 +388,14 @@ public func zip<T>(_ futures: [Future<T>]) -> Future<[T]> {
388
388
for future in futures {
389
389
future. observe { state in
390
390
switch state {
391
- case let . resulted( . value ( value) ) :
391
+ case let . resulted( . success ( value) ) :
392
392
lock. lock ( )
393
393
defer { lock. unlock ( ) }
394
394
results. append ( value)
395
395
guard results. count == count else { return }
396
- zippedFuture. become ( . resulted( with: . value ( results) ) )
397
- case let . resulted( . error ( reason) ) :
398
- zippedFuture. become ( . resulted( with: . error ( reason) ) )
396
+ zippedFuture. become ( . resulted( with: . success ( results) ) )
397
+ case let . resulted( . failure ( reason) ) :
398
+ zippedFuture. become ( . resulted( with: . failure ( reason) ) )
399
399
case . canceled:
400
400
zippedFuture. become ( . canceled)
401
401
case . waiting: break
@@ -417,9 +417,9 @@ public func future<T>(on worker: Worker = OperationQueue(), _ body: @escaping ()
417
417
let future : Future < T > = . init( executionContext: . explicit( worker) )
418
418
worker. schedule {
419
419
do {
420
- try future. become ( . resulted( with: . value ( body ( ) ) ) )
420
+ try future. become ( . resulted( with: . success ( body ( ) ) ) )
421
421
} catch {
422
- future. become ( . resulted( with: . error ( error) ) )
422
+ future. become ( . resulted( with: . failure ( error) ) )
423
423
}
424
424
}
425
425
return future
0 commit comments