anchor.diff:  /// (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:
   ///
  
positive.code: ///
  /// Inherited widgets, when referenced in this way, will cause the consumer to
  /// rebuild when the inherited widget itself changes state.
  abstract class InheritedWidget extends ProxyWidget {
    /// Abstract const constructor. This constructor enables subclasses to provide
    /// const constructors so that they can be used in const expressions.
  
negative.code: ///
  /// Keys must be unique amongst the [Element]s with the same parent. By
  /// contrast, [GlobalKey]s must be unique across the entire app.
  ///
  /// See also the discussion at [Widget.key].
  abstract class LocalKey extends Key {
    /// Default constructor, used by subclasses.
    const LocalKey() : super._();
  