More minor type improvements in dart:async.

sdk/lib/async/future.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 /// A type representing values that are either `Future<T>` or `T`.
 ///
 /// This class declaration is a public stand-in for an internal
 /// future-or-value generic type. References to this class are resolved to the
@@ skipping 243 matching lines @@
    * If [computation] is omitted,
    * it will be treated as if [computation] was set to `() => null`,
    * and the future will eventually complete with the `null` value.
    *
    * If calling [computation] throws, the created future will complete with the
    * error.
    *
    * See also [Completer] for a way to create and complete a future at a
    * later time that isn't necessarily after a known fixed duration.
    */
-  factory Future.delayed(Duration duration, [computation()]) {
+  factory Future.delayed(Duration duration, [FutureOr<T> computation()]) {
     _Future<T> result = new _Future<T>();
     new Timer(duration, () {
       try {
         result._complete(computation?.call());
       } catch (e, s) {
         _completeWithErrorCallback(result, e, s);
       }
     });
     return result;
   }
@@ skipping 140 matching lines @@
    * Runs [f] for each element in [input] in order, moving to the next element
    * only when the [Future] returned by [f] completes. Returns a [Future] that
    * completes when all elements have been processed.
    *
    * The return values of all [Future]s are discarded. Any errors will cause the
    * iteration to stop and will be piped through the returned [Future].
    *
    * If [f] returns a non-[Future], iteration continues immediately. Otherwise
    * it waits for the returned [Future] to complete.
    */
-  static Future forEach<T>(Iterable<T> input, f(T element)) {
+  static Future forEach<T>(Iterable<T> input, dynamic f(T element)) {
     var iterator = input.iterator;
     return doWhile(() {
       if (!iterator.moveNext()) return false;
       return new Future.sync(() => f(iterator.current)).then((_) => true);
     });
   }
 
   /**
    * Performs an async operation repeatedly until it returns `false`.
    *
    * The function [f] is called repeatedly while it returns either the [bool]
    * value `true` or a [Future] which completes with the value `true`.
    *
    * If a call to [f] returns `false` or a [Future] that completes to `false`,
    * iteration ends and the future returned by [doWhile] is completed.
    *
    * If a future returned by [f] completes with an error, iteration ends and
    * the future returned by [doWhile] completes with the same error.
    *
    * The [f] function must return either a `bool` value or a [Future] completing
    * with a `bool` value.
    */
-  static Future doWhile(f()) {
+  static Future doWhile(FutureOr<bool> f()) {
     _Future doneSignal = new _Future();
     var nextIteration;
     // Bind this callback explicitly so that each iteration isn't bound in the
     // context of all the previous iterations' callbacks.
     nextIteration = Zone.current.bindUnaryCallback((bool keepGoing) {
       if (keepGoing) {
         new Future.sync(f)
             .then(nextIteration, onError: doneSignal._completeError);
       } else {
         doneSignal._complete(null);
@@ skipping 133 matching lines @@
    *         var f2 = action();
    *         if (f2 is Future) return f2.then((_) => v);
    *         return v
    *       }, onError: (e) {
    *         var f2 = action();
    *         if (f2 is Future) return f2.then((_) { throw e; });
    *         throw e;
    *       });
    *     }
    */
-  Future<T> whenComplete(action());
+  Future<T> whenComplete(dynamic action());
 
   /**
    * Creates a [Stream] containing the result of this future.
    *
    * The stream will produce single data or error event containing the
    * completion result of this future, and then it will close with a
    * done event.
    *
    * If the future never completes, the stream will not produce any events.
    */
   Stream<T> asStream();
 
   /**
    * Time-out the future computation after [timeLimit] has passed.
    *
    * Returns a new future that completes with the same value as this future,
    * if this future completes in time.
    *
    * If this future does not complete before `timeLimit` has passed,
    * the [onTimeout] action is executed instead, and its result (whether it
    * returns or throws) is used as the result of the returned future.
    * The [onTimeout] function must return a [T] or a `Future<T>`.
    *
    * If `onTimeout` is omitted, a timeout will cause the returned future to
    * complete with a [TimeoutException].
    */
-  Future<T> timeout(Duration timeLimit, {onTimeout()});
+  Future<T> timeout(Duration timeLimit, {FutureOr<T> onTimeout()});
 }
 
 /**
  * Thrown when a scheduled timeout happens while waiting for an async result.
  */
 class TimeoutException implements Exception {
   /** Description of the cause of the timeout. */
   final String message;
   /** The duration that was exceeded. */
   final Duration duration;
@@ skipping 179 matching lines @@
   AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
   if (replacement != null) {
     error = _nonNullError(replacement.error);
     stackTrace = replacement.stackTrace;
   }
   result._completeError(error, stackTrace);
 }
 
 /** Helper function that converts `null` to a [NullThrownError]. */
 Object _nonNullError(Object error) => error ?? new NullThrownError();