1. PMKPromise 만들기

PMKPromise new:
    PMKPromise promiseWithResolver:block
        block1(resolve);// 

일

block1(PMKResolver resolve)
{
    id rejecter = ^(id error){
        if (error == nil) {
            error = NSErrorFromNil();
        } else if (IsPromise(error) && [error rejected]) {
            // this is safe, acceptable and (basically) valid
        } else if (!IsError(error)) {
            id userInfo = @{NSLocalizedDescriptionKey: [error description], PMKUnderlyingExceptionKey: error};
            error = [NSError errorWithDomain:PMKErrorDomain code:PMKInvalidUsageError userInfo:userInfo];
        }
        resolve(error);
    };

    id fulfiller = ^(id result){
        if (IsError(result))
            PMKLog(@"PromiseKit: Warning: PMKFulfiller called with NSError.");
        resolve(result);
    };

    block2(fulfiller, rejecter);
}

이

block2(PMKPromiseFulfiller fulfiller, PMKPromiseRejecter rejecter) {
    // 
    // fulfiller   rejecter
    // ：result | error  
}

삼

fulfiller | rejecter
    resolve(id)

사

resolve(id result) {    //result = NSError/id(PKMArray)/PMKPromise
    if (PMKGetResult(this))
        return PMKLog(@"PromiseKit: Warning: Promise already resolved");

    PMKResolve(this, result);
}

오

static void PMKResolve(PMKPromise *this, id result) {
    void (^set)(id) = ^(id r){
        NSArray *handlers = PMKSetResult(this, r);
        for (void (^handler)(id) in handlers)
            handler(r);
    };

    if (IsPromise(result)) {
        PMKPromise *next = result;
        dispatch_barrier_sync(next->_promiseQueue, ^{
            id nextResult = next->_result;
            
            if (nextResult == nil) {  // ie. pending
                [next->_handlers addObject:^(id o){
                    PMKResolve(this, o);
                }];
            } else
                set(nextResult);
        });
    } else
        set(result);
}

육

handler(r);    PMKPromise._handlers

2. 문제:_handlers는 언제 원소를 넣습니까

block2(q, ourBlock) 
{

    ourBlock = [ourBlock copy];

    __block PMKPromise *next = nil;

    dispatch_barrier_sync(_promiseQueue, ^{
        if ((result = _result))
            return;

        __block PMKPromiseFulfiller resolver;
        next = [PMKPromise new:^(PMKPromiseFulfiller fulfill, PMKPromiseRejecter reject) {
            resolver = ^(id o){
                if (IsError(o)) reject(o); else fulfill(o);
            };
        }];

        // 
        [_handlers addObject:^(id value){
            mkpendingCallback(value, next, q, ourBlock, resolver);
        }];
    });

    return next ?: mkresolvedCallback(result)(q, ourBlock);
}

mkpendingCallback(value, next, q, ourBlock, resolver);
mkpendingCallback(id result, PMKPromise *next, dispatch_queue_t q, id ourBlock, void (^resolve)(id)) 
{
    if (IsError(result))
        PMKResolve(next, result);
    else dispatch_async(q, ^{
        resolve(pmk_safely_call_block(ourBlock, result));
    });
}

pmk_safely_call_block(ourBlock, result)
{
    ourBlock(result[0], result[1], result[2]);
}