anchor.diff:      return shouldStartAnimation;
     }
   
  -  /// Subclasses must implement this function by running through the following
  -  /// steps for each animatable facet in the class:
  -  ///
  -  /// 1. Call the visitor callback with three arguments, the first argument
  -  /// being the current value of the Tween<T> object that represents the
  -  /// tween (initially null), the second argument, of type T, being the value
  -  /// on the Widget that represents the current target value of the
  -  /// tween, and the third being a callback that takes a value T (which will
  -  /// be the second argument to the visitor callback), and that returns an
  -  /// Tween<T> object for the tween, configured with the given value
  -  /// as the begin value.
  -  ///
  -  /// 2. Take the value returned from the callback, and store it. This is the
  -  /// value to use as the current value the next time that the [forEachTween]
  -  /// method is called.
  +  /// Visits each tween controlled by this state with the specified `visitor`
  +  /// function.
  +  ///
  +  /// ### Subclass responsibility
  +  ///
  +  /// Properties to be animated are represented by [Tween] member variables in
  +  /// the state. For each such tween, [forEachTween] implementations are
  +  /// expected to call `visitor` with the appropriate arguments and store the
  +  /// result back into the member variable. The arguments to `visitor` are as
  +  /// follows:
  +  ///
  +  /// {@macro flutter.widgets.implicit_animations.tweenVisitorArguments}
  +  ///
  +  /// ### When this method will be called
  +  ///
  +  /// [forEachTween] is initially called during [initState]. It is expected that
  +  /// the visitor's `tween` argument will be set to null, causing the visitor to
  +  /// call its `constructor` argument to construct the tween for the first time.
  +  /// The resulting tween will have its `begin` value set to the target value
  +  /// and will have its `end` value set to null. The animation will not be
  +  /// started.
  +  ///
  +  /// When this state's [widget] is updated (thus triggering the
  +  /// [didUpdateWidget] method to be called), [forEachTween] will be called
  +  /// again to check if the target value has changed. If the target value has
  +  /// changed, signaling that the [animation] should start, then the visitor
  +  /// will update the tween's `start` and `end` values accordingly, and the
  +  /// animation will be started.
  +  ///
  +  /// ### Other member variables
     ///
     /// Subclasses that contain properties based on tweens created by
     /// [forEachTween] should override [didUpdateTweens] to update those
  
positive.code:   TextStyle lerp(double t) => TextStyle.lerp(begin, end, t);
  }
  
  /// An abstract widget for building widgets that gradually change their
  /// values over a period of time.
  ///
  /// Subclasses' States must provide a way to visit the subclass's relevant
  /// fields to animate. [ImplicitlyAnimatedWidget] will then automatically
  /// interpolate and animate those fields using the provided duration and
  /// curve when those fields change.
  abstract class ImplicitlyAnimatedWidget extends StatefulWidget {
    /// Initializes fields for subclasses.
    ///
  
negative.code:   ///
    /// Any properties that depend upon tweens created by [forEachTween] should be
    /// updated within [didUpdateTweens], not within [forEachTween].
    ///
    /// This method will be called both:
    ///
    ///  1. After the tweens are _initially_ constructed (by
    ///     the `constructor` argument to the [TweenVisitor] that's passed to
    ///     [forEachTween]). In this case, the tweens are likely to contain only
    ///     a [Tween.begin] value and not a [Tween.end].
    ///
    ///  2. When the state's [widget] is updated, and one or more of the tweens
    ///     visited by [forEachTween] specifies a target value that's different
    ///     than the widget's current value, thus signaling that the [animation]
    ///     should run. In this case, the [Tween.begin] value for each tween will
    ///     an evaluation of the tween against the current [animation], and the
    ///     [Tween.end] value for each tween will be the target value.
    @protected
    void didUpdateTweens() { }
  }
  