description

# Future<T>.delayed constructor

Future<T>.delayed(

1. Duration duration, [
2. FutureOr<T> computation()?

])

Creates a future that runs its computation after a delay.

The `computation` will be executed after the given `duration` has passed, and the future is completed with the result of the computation.

If `computation` returns a future, the future returned by this constructor will complete with the value or error of that future.

If the duration is 0 or less, it completes no sooner than in the next event-loop iteration, after all microtasks have run.

If `computation` is omitted, it will be treated as if `computation` was `() => null`, and the future will eventually complete with the `null` value. In that case, `T` must be nullable.

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.

Example:

    Future.delayed(const Duration(seconds: 1), () {
      print('One second has passed.'); // Prints after 1 second.
    });

## Implementation

    factory Future.delayed(Duration duration, [FutureOr<T> computation()?]) {
      if (computation == null && !typeAcceptsNull<T>()) {
        throw ArgumentError.value(
          null,
          "computation",
          "The type parameter is not nullable",
        );
      }
      _Future<T> result = _Future<T>();
      Timer(duration, () {
        if (computation == null) {
          result._complete(null as T);
        } else {
          FutureOr<T> computationResult;
          try {
            computationResult = computation();
          } catch (e, s) {
            _completeWithErrorCallback(result, e, s);
            return;
          }
          result._complete(computationResult);
        }
      });
      return result;
    }