docs: public static <V> PnkyPromise<List<V>> all(
        final Iterable<? extends PnkyPromise<? extends V>> promises)
    {
      final Pnky<List<V>> pnky = Pnky.create();
  
      final int numberOfPromises = Iterables.size(promises);
  
      // Special case, no promises to wait for
      if (numberOfPromises == 0)
      {
        return Pnky.immediatelyComplete(Collections.<V> emptyList());
      }
  
      final AtomicInteger remaining = new AtomicInteger(numberOfPromises);
      @SuppressWarnings("unchecked")
      final V[] results = (V[]) new Object[numberOfPromises];
      final Throwable[] errors = new Throwable[numberOfPromises];
      final AtomicBoolean failed = new AtomicBoolean();
  
      int i = 0;
      for (final PnkyPromise<? extends V> promise : promises)
      {
        final int promiseNumber = i++;
  
        promise.alwaysAccept(new ThrowingBiConsumer<V, Throwable>()
        {
          @Override
          public void accept(final V result, final Throwable error) throws Throwable
          {
            results[promiseNumber] = result;
            errors[promiseNumber] = error;
            if (error != null)
            {
              failed.set(true);
            }
  
            if (remaining.decrementAndGet() == 0)
            {
              if (failed.get())
              {
                pnky.reject(new CombinedException(Arrays.asList(errors)));
              }
              else
              {
                pnky.resolve(Arrays.asList(results));
              }
            }
          }
        });
      }
  
      return pnky;
    }