Add support for Each extension about promises HOT 4 CLOSED

Replying to Matias' comment: "We basically want a mechanism where we can supply an array of promises, execute them one at a time serially, and then be able to chain an additional promise to be executed when this set of promises is done."

You should be able to more easily accomplish this with the newly added reduce operator:
https://github.com/google/promises/blob/master/g3doc/index.md#reduce

Please let us know if you have any additional questions or suggestions on how we can improve our API. Thank you!

from promises.

Hi Matias,

Many thanks for the suggestion! Unfortunately, even if we added something similar to each, that probably wouldn't work for the case you've mentioned.

The issue with all is that it expects a sequence of promises, which means some of the promises in such sequence may potentially get resolved concurrently on different queues before they were even passed to all or before all had a chance to subscribe for them and observe for state changes.

To guarantee serial resolution of promises you'd need to create them serially. Presumably, something like the following template would work for your scenario:

Swift:

values.reduce(initialPromise) { previousPromise, currentValue in
  previousPromise.then { previousValue in
    // Do something with the previous and current values to compute the next value.
    return nextValue
  }
}.then { resultingValue in
  // Do something with the resulting value.
}

Objective-C (powered with FBLFunctional):

[[values fbl_reduce:initialPromise
            combine:^FBLPromise *(FBLPromise *previousPromise, id currentValue) {
              return [previousPromise then:^id(id previousValue) {
                // Do something with the previous and current values to compute the next value.
                return nextValue;
              }];
            }] then:^id(id resultingValue) {
              // Do something with the resulting value.
              return sum;
            }];

A naive example:

Swift:

[1, 2, 3].reduce(Promise(0)) { promise, number in
  promise.then { partialSum in
    partialSum + number
  }
}.then { sum in
  print(sum)
}

Objective-C:

[[@[@1, @2, @3] fbl_reduce:[FBLPromise resolvedWith:@0]
                   combine:^FBLPromise *(FBLPromise *promise, NSNumber *number) {
                      return [promise then:^id(NSNumber *partialSum) {
                        return @(partialSum.integerValue + number.integerValue);
                      }];
                   }] then:^id(NSNumber *sum) {
                     NSLog(@"%@", sum);
                     return sum;
                   }];

Please, let us know if that doesn't work for you or if you have any further ideas or suggestions.

Thanks!

from promises.

I would like to (posthumously?) +1 this issue on the off chance others are doing what I'm doing - currently I use following hack to ensure that parent objects sync before child objects (I don't need to pass data down the chain, but I do care about deterministic order of operations):

RequestFactory(forEntity: Post.self, operations: [.create])
.then { (nothing) -> Promise<Void> in
  return RequestFactory(forEntity: Comments.self, operations [.create])
}

It would be lovely to have some sort of syntactic sugar around this, even if it was in an "advanced" section and had a big warning about "here be dragons" or something. I'd be happy to help clarify anything above if needed.

Thanks very much for your work on this library, it is delightful to use.

from promises.

Hi Jeremy, absolutely, any suggestions on such syntactic sugar and usage examples are highly appreciated! We strive to constantly improve this lib.

from promises.