anchor.diff:  /// Changing the [StreamBuilder] configuration to another stream during event
   /// generation introduces snapshot pairs of the form
   ///
  -/// * `new AsyncSnapshot<int>(ConnectionState.none, 5, null)`
  -/// * `new AsyncSnapshot<int>(ConnectionState.waiting, 5, null)`
  +/// * `AsyncSnapshot<int>.withData(ConnectionState.none, 5)`
  +/// * `AsyncSnapshot<int>.withData(ConnectionState.waiting, 5)`
   ///
   /// The latter will be produced only when the new stream is non-null. The former
   /// only when the old stream is non-null.
   ///
   /// The stream may produce errors, resulting in snapshots of the form
   ///
  -/// * `new AsyncSnapshot<int>(ConnectionState.active, null, 'some error')`
  +/// * `AsyncSnapshot<int>.withError(ConnectionState.active, 'some error')`
   ///
   /// The data and error fields of snapshots produced are only changed when the
   /// state is `ConnectionState.active`.
  
positive.code: /// For a future that completes successfully with data, the [builder] may
  /// be called with either both or only the latter of the following snapshots:
  ///
  /// * `new AsyncSnapshot<String>(ConnectionState.waiting, null, null)`
  /// * `new AsyncSnapshot<String>(ConnectionState.done, 'some data', null)`
  ///
  /// For a future completing with an error, the [builder] may be called with
  /// either both or only the latter of:
  ///
  /// * `new AsyncSnapshot<String>(ConnectionState.waiting, null, null)`
  /// * `new AsyncSnapshot<String>(ConnectionState.done, null, 'some error')`
  ///
  /// The data and error fields of the snapshot change only as the connection
  /// state field transitions from `waiting` to `done`, and they will be retained
  
negative.code: /// old future has already completed successfully with data as above, changing
  /// configuration to a new future results in snapshot pairs of the form:
  ///
  /// * `AsyncSnapshot<String>.withData(ConnectionState.none, 'some data')`
  /// * `AsyncSnapshot<String>.withData(ConnectionState.waiting, 'some data')`
  ///
  /// In general, the latter will be produced only when the new future is
  /// non-null. The former only when the old future is non-null.
  