anchor.diff:  typedef bool Matcher<S, T>(S source, T target);
   typedef T Mapper<S, T>(S source);
   
  -// TODO: RECYCLE Items!
  -// TODO: Be smart about minimal changes
  +/*
  + * Well, hmm. So this impl will do an okay job of not calling mapper too often
  + * but we're paying the hash lookup cost on every indexer access
  + *
  + * So...we could throw memory at it...or get more clever
  + * ...but this works for now
  + */
   
   class MappedListView<S, T> extends _UnmodifiableListBase<T> {
   
  
positive.code:     _source.changes.listen(_list_changes);
    }
  
    int get length => _view.length;
  
    T operator[](int index) => _view[index];
  
    //
    // Implementation
    //
  
    List<T> get _view {
      if(_isDirty) {
        _content = _source.map(_mapper).toList(growable: false);
        _isDirty = false;
      }
      return _content;
    }
  
    void _list_changes(List<ChangeRecord> changes) {
      _isDirty = true;
      changes.forEach(notifyChange);
    }
  }
  
negative.code:   final Matcher<S, T> _matcher;
    final Mapper<S, T> _mapper;
  
    final Map<S, T> _cache = new Map<S, T>();
    bool _isDirty = true;
  
    MappedListView(this._source, this._matcher, this._mapper) {
  