description

# any<T> static method

Future<T> any<T>(

1. Iterable<Future<T>> futures

)

Returns the result of the first future in `futures` to complete.

The returned future is completed with the result of the first future in `futures` to report that it is complete, whether it's with a value or an error. The results of all the other futures are discarded.

If `futures` is empty, or if none of its futures complete, the returned future never completes.

Example:

    void main() async {
      final result =
          await Future.any([slowInt(), delayedString(), fastInt()]);
      // The future of fastInt completes first, others are ignored.
      print(result); // 3
    }
    Future<int> slowInt() async {
      await Future.delayed(const Duration(seconds: 2));
      return 2;
    }

    Future<String> delayedString() async {
      await Future.delayed(const Duration(seconds: 2));
      throw TimeoutException('Time has passed');
    }

    Future<int> fastInt() async {
      await Future.delayed(const Duration(seconds: 1));
      return 3;
    }

## Implementation

    static Future<T> any<T>(Iterable<Future<T>> futures) {
      var completer = Completer<T>.sync();
      void onValue(T value) {
        if (!completer.isCompleted) completer.complete(value);
      }

      void onError(Object error, StackTrace stack) {
        if (!completer.isCompleted) completer.completeError(error, stack);
      }

      for (var future in futures) {
        future.then(onValue, onError: onError);
      }
      return completer.future;
    }