anchor.diff:    /// When all futures have completed, the stream is closed.
     ///
     /// If [futures] is empty, the stream closes as soon as possible.
  +  ///
  +  /// Example:
  +  /// ```dart
  +  /// Future<int> waitTask() async {
  +  ///   await Future.delayed(const Duration(seconds: 2));
  +  ///   return 10;
  +  /// }
  +  ///
  +  /// Future<String> doneTask() async {
  +  ///   await Future.delayed(const Duration(seconds: 5));
  +  ///   return 'Future complete';
  +  /// }
  +  ///
  +  /// final stream = Stream<Object>.fromFutures([doneTask(), waitTask()]);
  +  /// stream.listen(print, onDone: () => print('Done'), onError: print);
  +  ///
  +  /// // Outputs:
  +  /// // 10 after 'waitTask' finished.
  +  /// // "Future complete" after 'doneTask' finished.
  +  /// // "Done" when stream completed.
  +  /// ```
     factory Stream.fromFutures(Iterable<Future<T>> futures) {
       _StreamController<T> controller =
           new _SyncStreamController<T>(null, null, null, null);
  
positive.code:   /// instead of the first.
    /// That means that a non-error result cannot be provided before this stream
    /// is done.
    Future<T> lastWhere(bool test(T element), {T orElse()?}) {
      _Future<T> future = new _Future();
      late T result;
  
negative.code:   /// The returned stream is a broadcast stream if this stream is.
    /// For a broadcast stream, the events are only tested from the time
    /// the returned stream is listened to.
    ///
    /// Example:
    /// ```dart
    /// final stream = Stream<int>.periodic(const Duration(seconds: 1), (i) => i)
    ///     .takeWhile((event) => event < 6);
    /// stream.forEach(print); // Outputs events: 0, ..., 5.
    /// ```
    Stream<T> takeWhile(bool test(T element)) {
      return new _TakeWhileStream<T>(this, test);
    }
  