anchor.diff:    /// widget is inflated into an element, and the new element is inserted into the
     /// tree.
     ///
  -  /// Using a [GlobalKey] as the widget's [key] allows the element to be moved
  -  /// around the tree (changing parent) without losing state. When a new widget
  -  /// is found (its key and type do not match a previous widget in the same
  -  /// location), but there was a widget with that same global key elsewhere in
  -  /// the tree in the previous frame, then that widget's element is moved to the
  -  /// new location.
  +  /// In addition, using a [GlobalKey] as the widget's [key] allows the element
  +  /// to be moved around the tree (changing parent) without losing state. When a
  +  /// new widget is found (its key and type do not match a previous widget in
  +  /// the same location), but there was a widget with that same global key
  +  /// elsewhere in the tree in the previous frame, then that widget's element is
  +  /// moved to the new location.
  +  ///
  +  /// Generally, a widget that is the only child of another widget does not need
  +  /// an explicit key.
  +  ///
  +  /// See also the discussions at [Key] and [GlobalKey].
     final Key key;
   
     /// Inflates this configuration to a concrete instance.
  
positive.code: /// Keys must be unique amongst the [Element]s with the same parent.
  ///
  /// Subclasses of [Key] should either subclass [LocalKey] or [GlobalKey].
  @immutable
  abstract class Key {
    /// Construct a [ValueKey<String>] with the given [String].
  
negative.code: /// (instead of being recreated) in the new location. However, in order to be
  /// eligible for grafting, the widget might be inserted into the new location in
  /// the same animation frame in which it was removed from the old location.
  ///
  /// ## Sample code
  ///
  /// The following is a skeleton of a stateful widget subclass called `GreenFrog`:
  ///
  /// ```dart
  /// class GreenFrog extends StatefulWidget {
  ///   const GreenFrog({ Key key }) : super(key: key);
  ///
  ///   @override
  ///   _GreenFrogState createState() => new _GreenFrogState();
  /// }
  ///
  /// class _GreenFrogState extends State<GreenFrog> {
  ///   @override
  ///   Widget build(BuildContext context) {
  ///     return new Container(color: const Color(0xFF2DBD3A));
  ///   }
  /// }
  /// ```
  ///
  /// In this example. the [State] has no actual state. State is normally
  /// represented as private member fields. Also, normally widgets have more
  /// constructor arguments, each of which corresponds to a `final` property.
  ///
  /// The next example shows the more generic widget `Frog` which can be given a
  /// color and a child, and which has some internal state with a method that
  /// can be called to mutate it:
  ///
  /// ```dart
  /// class Frog extends StatelessWidget {
  ///   const Frog({
  ///     Key key,
  ///     this.color: const Color(0xFF2DBD3A),
  ///     this.child,
  ///   }) : super(key: key);
  ///
  ///   final Color color;
  ///
  ///   final Widget child;
  ///
  ///   _FrogState createState() => new _FrogState();
  /// }
  ///
  /// class _FrogState extends State<Frog> {
  ///   double _size = 1.0;
  ///
  ///   void grow() {
  ///     setState(() { _size += 0.1; });
  ///   }
  ///
  ///   @override
  ///   Widget build(BuildContext context) {
  ///     return new Container(
  ///       color: widget.color,
  ///       transform: new Matrix4.diagonalValues(_size, _size, 1.0),
  ///       child: widget.child,
  ///     );
  ///   }
  /// }
  /// ```
  ///
  /// By convention, widget constructors only use named arguments. Named arguments
  /// can be marked as required using [@required]. Also by convention, the first
  /// argument is [key], and the last argument is `child`, `children`, or the
  /// equivalent.
  ///
  /// See also:
  ///
  