Promise of an API

Promise of an API
Maxim Zaks (@iceX33)
CocoaHeads Berlin

Agenda
— Consume a promise
— Produce a promise
— Swift

- (NSNumber*)addFirstNumber:(NSNumber*)number1
toSecondNumber:(NSNumber*)number2;

toSecondNumber:(NSNumber*)number2
withError:(NSError**)error;

- (void)addFirstNumber:(NSNumber*)number1
withBlock:(void (^)(NSNumber *sum, NSError *error))block;

withBlock:(void (^)(NSNumber *sum, NSError *error))block;
success:(void (^)(NSNumber *sum))success
failure:(void (^)(NSError *error))failur;

And now with a real promise!
- (OMPromise*)addFirstNumber:(NSNumber*)number1

What is a promise
(OMPromise)?
It's just an object

It has state
— Unfulﬁlled
— Fulﬁlled
— Failed

It has other properties
— result
— error
— progress*

It has methods
- (OMPromise *)fulfilled:(void (^)(id result))fulfilHandler;
- (OMPromise *)failed:(void (^)(NSError *error))failHandler;
- (OMPromise *)progressed:(void (^)(float progress))progressHandler;

It lets you call handlers on a custom queue
- (OMPromise *)fulfilled:(void (^)(id result))fulfilHandler on:(dispatch_queue_t)queue;
- (OMPromise *)failed:(void (^)(NSError *error))failHandler on:(dispatch_queue_t)queue;
- (OMPromise *)progressed:(void (^)(float progress))progressHandler on:(dispatch_queue_t)queue;

OMPromise *sum = [calc addFirstNumber:@3 toSecondNumber:@2];
[[sum fulﬁlled:^(id result){
NSLog(@"Sum: %@", result);
}] failed:^(NSError *error){
NSLog(@"Failed to calculate because of: %@", error);
}];

Concatenation
sum1 = 3 + 2
sum2 = sum1 + 2
sum3 = sum1 + 3

Concatenation
OMPromise *sum1 = [calc addFirstNumber:@3 toSecondNumber:@2];
OMPromise *sum2 = [sum1 than:^(NSNumber *n1){
return [calc addFirstNumber:n1 toSecondNumber:@2];
}];
OMPromise *sum3 = [sum1 than:^(NSNumber *n1){
}];
[[[OMPromise all:@[sum1, sum2, sum3]] fulﬁlled:^(NSArray *results){
NSLog(@"Sum1: %@, Sum2: %@, Sum3: %@", results[0], results[1], results[2]);
} on:dispatch_get_main_queue()] failed:^(NSError *error){
NSLog(@"Failed to calculate because of: %@", error);
} on:dispatch_get_main_queue()];

Deep chaining
OMPromise *sum = [OMPromise chain:[
^(NSNumber *n1){
return [calc addFirstNumber:@2 toSecondNumber:@3];
},
^(NSNumber *n1){
},
^(NSNumber *n1){
}
] initial:nil];

Recovering from failed promise
OMPromise *sum1 = [calc addFirstNumber:@3 toSecondNumber:@2];
OMPromise *rescuedSum = [sum1 rescue:^(NSError *error){
NSLog(@"Shit happens! %@", error);
return @0;
}];

Recap 1/3
@interface OMPromise : NSObject
@property(assign, readonly, nonatomic) OMPromiseState state;
@property(readonly, nonatomic) id result;
@property(readonly, nonatomic) NSError *error;
@property(assign, readonly, nonatomic) ﬂoat progress;

Recap 2/3
- (OMPromise *)fulfilled:(void (^)(id result))fulfilHandler;
- (OMPromise *)failed:(void (^)(NSError *error))failHandler;
- (OMPromise *)progressed:(void (^)(float progress))progressHandler;
- (OMPromise *)then:(id (^)(id result))thenHandler;
- (OMPromise *)rescue:(id (^)(NSError *error))rescueHandler;

Recap 3/3
+ (OMPromise *)chain:(NSArray *)thenHandlers initial:(id)result;
+ (OMPromise *)any:(NSArray *)promises;
+ (OMPromise *)all:(NSArray *)promises;

Now what's about creating a
promise?

Convenience methods on OMPromise
+ (OMPromise *)promiseWithResult:(id)result;
+ (OMPromise *)promiseWithResult:(id)result after:(NSTimeInterval)delay;
+ (OMPromise *)promiseWithError:(NSError *)error;
+ (OMPromise *)promiseWithTask:(id (^)())task;

Example for success
- (OMPromise *)addFirstNumber:(NSNumber*)number1
{
return [OMPromise promiseWithTask:^{
return @([n1 intValue] + [n2 intValue])
}];
}

Example for error
{
return [OMPromise promiseWithTask:^{
return [NSError new];
}];
}

And what is the non convenient
way?

Defered object
@interface OMDeferred : OMPromise
+ (OMDeferred *)deferred;
- (OMPromise *)promise;
- (void)fulﬁl:(id)result;
- (void)fail:(NSError *)error;
- (void)progress:(ﬂoat)progress;
@end

Example
{
OMDeferred *deferred = [OMDeferred deferred];
dispatch_async(dispatch_get_global_queue(0, 0), ^
{
NSError *error = nil;
NSNumber *sum = [self addFirstNumber:number1
toSecondNumber:number2
withError:&error];
if(error){
[deferred fail:error];
} else {
[deferred fulﬁll:sum];
}
});
return deferred.promise;
}

Recap
— Promise is an immutable data structure
— Deferred is a subclass of Promise which makes it
mutable

To add up confusion I
implemented promises in
Swift

First attempt was just to
port it

Using Enums for state representation feels right
enum PromiseState{
case Unfulﬁlled
case Fulﬁlled
case Failed
}

I need inheritance so let's
use classes

Using constants as read only property is not a good
idea as you have to set them directly in the
initializer
class Promise<T> {
let state : PromiseState
let result : T
let error : NSError
}

Switching to var makes it work but Promise is not
immutable any more
class Promise<T> {
var state : PromiseState
var result : T?
var error : NSError?
init(){
state = .Unfulfilled
}
func fulfill(value : T){
result = value
state = .Fulfilled
}
}

Trying to make a read only property
class Promise<T> {
var state : PromiseState
var result : T? {
get {
return self.result
}
}
var error : NSError?
init(){
state = .Unfulﬁlled
}
}

Sadly this was an inﬁnite loop
— There are no Read-Only properties in Swift
— Only Read-Only Computed Properties

Schock number 2
— There are no ivars in Swift
— And no visibility constrains (but they promised
to introduced those)

After initial shock pass, I
decided to go functional

func future<T>(execution : ()->FutureResult<T>)(handler: FutureHandler<T>) {
var result : FutureResult<T>?
var done = false
dispatch_async(dispatch_get_global_queue(0, 0)) {
result = execution()
done = true
}
dispatch_async(dispatch_get_global_queue(0, 0)) {
while !done {}
dispatch_async(dispatch_get_main_queue()) {
switch handler {
case .FulFilled(let fulﬁlled):
switch result! {
case .Result(let value):
fulﬁlled(value())
case .Error : println("can't process error")
}
case .Failed(let failed):
switch result! {
case .Result: println("can't process result")
case .Error(let error) : failed(error())
}
}
}
}
}

Main concept = currying
func add(n1:Int)(n2:Int) -> Int {
return n1 + n2
}
let increaseByTwo = add(2)
let sum = increaseByTwo(3)

Using enums with Associated Values
enum FutureHandler<T>{
case FulFilled((T)->())
case Failed((NSError)->())
}
enum FutureResult<T>{
case Result(@auto_closure ()->T)
case Error(@auto_closure ()->NSError)
}

Here is how you can use it:
var f = future {
FutureResult.Result(2 + 3)
}
f (handler: FutureHandler.FulFilled {
result in
println("Promise fulﬁlled : (result)")
})

It's not a beauty but it
works

However you can't concatenate futures in this
implementation
— typealias F = (FutureHandler<Int>) -> F

For the tough ones, who survived this talk:
— https://github.com/b52/OMPromises
— https://github.com/mzaks/siwft-future

Thank you!
Maxim Zaks (@iceX33)

Promise of an API

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Promise of an API

Ähnlich wie Promise of an API (20)

Mehr von Maxim Zaks

Mehr von Maxim Zaks (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Promise of an API