parallel_wait.dart

extension WaitFailFast2<A, B> on (Future<A>, Future<B>) {
  Future<(A, B)> get waitFailFast async {
    final results = await Future.wait([$1, $2]);
    return (results[0] as A, results[1] as B);
  }
}

extension WaitFailFast3<A, B, C> on (Future<A>, Future<B>, Future<C>) {
  Future<(A, B, C)> get waitFailFast async {
    final results = await Future.wait([$1, $2, $3]);
    return (results[0] as A, results[1] as B, results[2] as C);
  }
}

extension WaitFailFast4<A, B, C, D> on (Future<A>, Future<B>, Future<C>, Future<D>) {
  Future<(A, B, C, D)> get waitFailFast async {
    final results = await Future.wait([$1, $2, $3, $4]);
    return (results[0] as A, results[1] as B, results[2] as C, results[3] as D);
  }
}

extension WaitFailFast5<A, B, C, D, E> on (Future<A>, Future<B>, Future<C>, Future<D>, Future<E>) {
  Future<(A, B, C, D, E)> get waitFailFast async {
    final results = await Future.wait([$1, $2, $3, $4, $5]);
    return (results[0] as A, results[1] as B, results[2] as C, results[3] as D, results[4] as E);
  }
}

extension WaitFailFast6<A, B, C, D, E, F> on (Future<A>, Future<B>, Future<C>, Future<D>, Future<E>, Future<F>) {
  Future<(A, B, C, D, E, F)> get waitFailFast async {
    final results = await Future.wait([$1, $2, $3, $4, $5, $6]);
    return (results[0] as A, results[1] as B, results[2] as C, results[3] as D, results[4] as E, results[5] as F);
  }
}

extension WaitFailFast7<A, B, C, D, E, F, G> on (
  Future<A>,
  Future<B>,
  Future<C>,
  Future<D>,
  Future<E>,
  Future<F>,
  Future<G>
) {
  Future<(A, B, C, D, E, F, G)> get waitFailFast async {
    final results = await Future.wait([$1, $2, $3, $4, $5, $6, $7]);
    return (
      results[0] as A,
      results[1] as B,
      results[2] as C,
      results[3] as D,
      results[4] as E,
      results[5] as F,
      results[6] as G
    );
  }
}

extension WaitFailFast8<A, B, C, D, E, F, G, H> on (
  Future<A>,
  Future<B>,
  Future<C>,
  Future<D>,
  Future<E>,
  Future<F>,
  Future<G>,
  Future<H>
) {
  Future<(A, B, C, D, E, F, G, H)> get waitFailFast async {
    final results = await Future.wait([$1, $2, $3, $4, $5, $6, $7, $8]);
    return (
      results[0] as A,
      results[1] as B,
      results[2] as C,
      results[3] as D,
      results[4] as E,
      results[5] as F,
      results[6] as G,
      results[7] as H
    );
  }
}

class Futures {
  final _futures = <FutureValue<void>>[];

  FutureValue<T> wait<T>(Future<T> future) {
    final joinFuture = FutureValue<T>(future);
    _futures.add(joinFuture);
    return joinFuture;
  }

  Future<void> get done => Future.wait(_futures.map((future) => future._done));
}

class FutureValue<T> {
  FutureValue(Future<T> future) {
    _done = future.then((value) => this.value = value);
  }

  late final Future<void> _done;
  late final T value;
}

Future<void> foo() async {
  final futures = Futures();
  final a = futures.wait(Future.value(1));
  final b = futures.wait(Future.value(''));
  await futures.done;

  print(a.value);
  print(b.value);
}

class FutureKey<T> {
  FutureKey(this.future);

  final Future<T> future;
}

Future<FutureResults> parallelWait(List<FutureKey<void>> futures) async {
  final results = await Future.wait(futures.map((future) => future.future));
  return FutureResults._(Map.fromIterables(futures, results));
}

class FutureResults {
  FutureResults._(this._results);

  final Map<FutureKey<void>, Object?> _results;

  T call<T>(FutureKey<T> key) => _results[key] as T;
}

Future<void> bar() async {
  final a = FutureKey(Future.value(1));
  final b = FutureKey(Future.value(''));
  final results = await parallelWait([a, b]);

  print(results(a));
  print(results(b));
}