anchor.diff:    String _valueIdentifier;
     String _keyIdentifier;
     String _listExpr;
  -  List<_Row> _rows;
  +  List<View> _views;
     Function _generateId = (key, value, index) => value;
     Watch _watch;
   
  
positive.code:         ..[r'$even'] = index.isEven;
    }
  }
  
  class _Row {
    final id;
    Scope scope;
    View view;
    dom.Element startNode;
    dom.Element endNode;
    List<dom.Node> nodes;
  
    _Row(this.id);
  }
  
negative.code:     _watch = _scope.watch(
          _listExpr,
          (changes, _) {
            if (changes is CollectionChangeRecord && changes != null) {
              _onCollectionChange(changes);
            } else if (_views != null) {
              _views.forEach(_viewPort.remove);
              _views = null;
            }
          },
          collection: true,
          formatters: formatters
      );
    }
  
    void _onCollectionChange(CollectionChangeRecord changes) {
      final int length = changes.length;
      final views = new List<View>(length);
      final changeFunctions = new List<Function>(length);
      final removedIndexes = <int>[];
      final int domLength = _views == null ? 0 : _views.length;
      final leftInDom = new List.generate(domLength, (i) => domLength - 1 - i);
      var domIndex;
  
      Function addFn, moveFn, removeFn;
  
      if (_views == null) {
        addFn = changes.forEachItem;
        moveFn = (_) {};
        removeFn = (_) {};
      } else {
        addFn = changes.forEachAddition;
        moveFn = changes.forEachMove;
        removeFn = changes.forEachRemoval;
      }
  
      removeFn((CollectionChangeItem removal) {
        var index = removal.previousIndex;
        _viewPort.remove(_views[index]);
        leftInDom.removeAt(domLength - 1 - index);
      });
  
      addFn((CollectionChangeItem addition) {
        changeFunctions[addition.currentIndex] = (index, previousView) {
          var childContext = _updateContext(new PrototypeMap(_scope.context), index,length)
              ..[_valueIdentifier] = addition.item;
          var childScope = _scope.createChild(childContext);
          var view = views[index] = _boundViewFactory(childScope);
          _viewPort.insert(view, insertAfter: previousView);
        };
      });
  
      moveFn((CollectionChangeItem move) {
        var previousIndex = move.previousIndex;
        var value = move.item;
        changeFunctions[move.currentIndex] = (index, moveAfter) {
          var previousView = _views[previousIndex];
          var childScope = previousView.scope;
          var childContext = _updateContext(childScope.context, index, length);
          if (!identical(childScope.context[_valueIdentifier], value)) {
            childContext[_valueIdentifier] = value;
          }
          views[index] = _views[previousIndex];
          // Only move the DOM node when required
          if (domIndex < 0 || leftInDom[domIndex] != previousIndex) {
            _viewPort.move(previousView, moveAfter: moveAfter);
            leftInDom.remove(previousIndex);
          }
          domIndex--;
        };
      });
  
      var previousView = null;
      domIndex = leftInDom.length - 1;
      for(var targetIndex = 0; targetIndex < length; targetIndex++) {
        var changeFn = changeFunctions[targetIndex];
        if (changeFn == null) {
          views[targetIndex] = _views[targetIndex];
          if (domIndex < 0 || leftInDom[domIndex] != targetIndex) {
            _viewPort.move(views[targetIndex], moveAfter: previousView);
            leftInDom.remove(targetIndex);
          }
          domIndex--;
          // The element has not moved but `$last` and `$middle` might still need to be updated
          _updateContext(views[targetIndex].scope.context, targetIndex, length);
        } else {
          changeFn(targetIndex, previousView);
        }
        previousView = views[targetIndex];
      }
  
      _views = views;
    }
  
    PrototypeMap _updateContext(PrototypeMap context, int index, int length) {
  